@turri-dev/cli 0.1.3-next.79e2ad0 → 0.1.3-next.e5599c1

package/README.md

@@ -212,7 +212,7 @@ It runs the interview skill, asks you about the problem, the stack and the produ
   model and cost - and the queue behind it;
 - ask to try it at any time - "let me try it" - and **`release`** puts what is built so far in
   `dist/<module>` and **`activate`** starts it, installing what it needs - nothing to approve;
-- the **side panel** (`ctrl+h`) takes the screen and opens on **regen** (`/regen`) - \*\*\*plain, every item marked planned, working, regenerated, validating, conform or needs you - and `p` turns it to the **pulses** (`/pulses`) - every pulse, running, queued and finished, and what each regenerates; what its agents did is in each pulse's log in `.turri/jobs/`;
+- the **side panel** (`ctrl+h`) takes the screen and opens on **regen** - \*\*\*plain, every item marked planned, working, regenerated, validating, conform or needs you - and `p` turns it to the **pulses** (`/pulses`) - every pulse, running, queued and finished, and what each regenerates; what its agents did is in each pulse's log in `.turri/jobs/`;
 - **`/halt`** halts a pulse, **`/lineage`** shows every generation of a
   module, and the **`drift`** tool says what is left to regenerate;
 - **`/btw <question>`** asks turri something on the side - answered at once, even in the middle of a skill's interview

package/dist/environment.js

@@ -68,3 +68,22 @@ export function turriOnPath() {
     const found = which.status === 0 ? which.stdout.trim().split("\n")[0] : undefined;
     return found === "" ? undefined : found;
 }
+/** turri's version, and the commit when it runs from a clone. */
+export function turriIdentity() {
+    let version = null;
+    try {
+        version = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")).version ?? null;
+    }
+    catch {
+        /* no package.json: left out */
+    }
+    if (!existsSync(join(PACKAGE_ROOT, ".git")))
+        return { version, git_commit: null, git_dirty: null };
+    const commit = spawnSync("git", ["-C", PACKAGE_ROOT, "rev-parse", "HEAD"], { encoding: "utf8" });
+    const status = spawnSync("git", ["-C", PACKAGE_ROOT, "status", "--porcelain", "--untracked-files=no"], { encoding: "utf8" });
+    return {
+        version,
+        git_commit: commit.status === 0 ? commit.stdout.trim() : null,
+        git_dirty: status.status === 0 ? status.stdout.trim() !== "" : null,
+    };
+}

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, compositeTuiLine, getCapabilities, getPngDimensions, isKeyRelease, isKeyRepeat, matchesKey, renderImage, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease, isKeyRepeat, matchesKey, renderImage, Text, visibleWidth, 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";
@@ -31,6 +31,8 @@ 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 { 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 { skillAboutLine, skillProgressLine } from "./skill-progress.js";
 import { createSidePanel } from "./regenerate/side-panel.js";
 import { createSpecMapSource, defaultMapFiles } from "./regenerate/spec-map.js";
@@ -52,6 +54,7 @@ import { registerStacks } from "./stacks.js";
 import { catalogueLine, discoverSkills, leftOutNote } from "./skills.js";
 import { supersededByTurri } from "./chat-skills.js";
 import { TURRI_IDENTITY } from "./identity.js";
+import { turriIdentity } from "./environment.js";
 import { conformanceChooser } from "./regenerate/choose-conformance.js";
 import { answerSideQuestion, askWithAsides, BTW_HOW, runningSkill, skillRunStarted, skillSessionText, transcriptOf } from "./btw.js";
 import { createJobRegistry, defaultParallelJobs, describeJob, formatDuration, pulseName, shouldWait, STOPPED_ON_REQUEST, } from "./regenerate/jobs.js";
@@ -1467,9 +1470,17 @@ function registerJobTools(pi, jobs, cwd) {
             return { content: [{ type: "text", text }], details: {} };
         },
     });
-    // The side panel: the regeneration - and the pulses behind p - over the whole screen. Its key (PANEL_KEY) opens it; the
-    // key again, or esc, closes it and goes back to the chat. While it shows, every key is its own.
+    // 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.
+    // 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.
+    let panelDocked = false;
+    // 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);
     // 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();
@@ -1497,13 +1508,54 @@ function registerJobTools(pi, jobs, cwd) {
         needsLooking.delete(jobs);
         if (panel !== undefined) {
             panel.handle?.setHidden(false);
+            panel.keys = true;
             panel.handle?.focus();
             return;
         }
         // Not awaited: the panel lives on while the jobs it shows run.
         void ctx.ui.custom((tui, theme, _keybindings, done) => {
             const close = () => done(undefined);
+            panelTerminal = tui.terminal;
             let component;
+            // Beside the chat: the chat drawn narrower, on the left, and a click on either side giving it the keys - undone
+            // when the panel goes over the screen, or closes.
+            let undock;
+            const layOut = () => {
+                if (panelDocked && undock === undefined) {
+                    const widen = narrowChat(tui, panelBeside);
+                    const unwatch = clickToFocus(tui, () => tui.terminal.columns - panelBeside(), (side) => {
+                        if (panelBeside() === 0)
+                            return;
+                        if (side === "chat")
+                            toChat();
+                        else
+                            toPanel();
+                    });
+                    // The side without the keys in the shade: the chat while the panel has them.
+                    const unshade = shadeChat(tui, () => panelBeside() > 0 && entry.keys);
+                    undock = () => {
+                        unshade();
+                        unwatch();
+                        widen();
+                    };
+                }
+                else if (!panelDocked && undock !== undefined) {
+                    undock();
+                    undock = undefined;
+                }
+            };
+            // Beside the chat, back to it: the chat has the keys, the panel stays.
+            const toChat = () => {
+                entry.keys = false;
+                entry.handle?.unfocus();
+                tui.requestRender();
+            };
+            const toPanel = () => {
+                entry.keys = true;
+                entry.handle?.focus();
+                tui.requestRender();
+            };
+            const back = () => (panelBeside() > 0 ? toChat() : close());
             // Opened, it reads the files again at once: they may have changed while it was closed.
             specMap.refresh();
             const view = createSidePanel({
@@ -1513,6 +1565,14 @@ function registerJobTools(pi, jobs, cwd) {
                 mapState,
                 rows: () => tui.terminal.rows,
                 key: PANEL_KEY,
+                dock: {
+                    docked: () => panelBeside() > 0,
+                    toggle: () => {
+                        panelDocked = panelBeside() === 0;
+                        layOut();
+                        tui.requestRender();
+                    },
+                },
                 style: {
                     heading: (text) => theme.bold(theme.fg("accent", text)),
                     muted: (text) => theme.fg("muted", text),
@@ -1527,22 +1587,25 @@ function registerJobTools(pi, jobs, cwd) {
                     // What conformance tests show does what its spec says: brand blue.
                     conforms: brandBlue(theme),
                 },
-                back: close,
+                back,
                 close,
                 // A module that needs the person: the chat takes it up with them, in their words - what went wrong, and what now.
                 discuss: (page) => {
-                    close();
+                    back();
                     const why = page.codebase?.stuck?.why;
                     pi.sendUserMessage(`regen says ${page.module} needs me: ${page.status}. What went wrong, and what do we do about it?${why !== undefined ? `\n\n(turri's reason: ${why})` : ""}`, { deliverAs: "followUp" });
                 },
                 // Something took the keys' focus while the panel showed - a question in the chat - and waits there.
                 waiting: () => {
+                    if (!entry.keys)
+                        return false;
                     const focused = tui.getFocusedComponent?.() ?? null;
                     return focused !== null && focused !== component;
                 },
             });
-            const entry = { view, close };
+            const entry = { view, close, keys: true };
             panel = entry;
+            layOut();
             // Every key goes to the panel while it shows, whatever has the focus: a question the chat model asks in the
             // background takes the focus, but no key reaches it - an enter never answers it unseen. It waits in the chat
             // until the panel closes, and has the keys then. Mouse events are the screen's, before this sees them.
@@ -1564,6 +1627,22 @@ 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)
+                    return undefined;
+                entry.keys = true;
                 // A terminal on the Kitty keyboard protocol reports a key's release, and listeners are given it: the release of
                 // the ctrl+h that opened the panel would close it again at once, and every arrow would move twice. Only
                 // presses count - and ctrl+h held down, repeating, does not open and close it over and over.
@@ -1590,7 +1669,13 @@ function registerJobTools(pi, jobs, cwd) {
             }, WATCH_REDRAW_MS);
             timer.unref?.();
             component = {
-                render: (width) => view.render(width),
+                // Beside the chat, a rule down its left edge between them - and the panel in the shade while the chat has the keys.
+                render: (width) => {
+                    if (panelBeside() === 0)
+                        return view.render(width);
+                    const lines = view.render(width - 2).map((line) => `${theme.fg("borderMuted", "│")} ${line}`);
+                    return entry.keys ? lines : lines.map(shade);
+                },
                 // Reached only if the listener above is gone: the same, so the panel never passes a key on.
                 handleInput: (data) => {
                     if (isKeyRepeat(data) && matchesKey(data, PANEL_KEY))
@@ -1606,6 +1691,7 @@ function registerJobTools(pi, jobs, cwd) {
                 dispose: () => {
                     unlisten();
                     clearInterval(timer);
+                    undock?.();
                     if (panel === entry)
                         panel = undefined;
                 },
@@ -1613,34 +1699,36 @@ function registerJobTools(pi, jobs, cwd) {
             return component;
         }, {
             overlay: true,
-            // The whole screen: the panel or the chat, one at a time.
-            overlayOptions: { width: "100%", maxHeight: "100%", anchor: "top-left", margin: 0 },
+            // The whole screen, or the columns on the right beside the chat - read at each frame, so it follows the terminal.
+            overlayOptions: {
+                get width() {
+                    return panelBeside() > 0 ? panelBeside() : "100%";
+                },
+                maxHeight: "100%",
+                anchor: "top-right",
+                margin: 0,
+            },
             onHandle: (handle) => {
                 if (panel !== undefined)
                     panel.handle = handle;
             },
         });
     };
-    // The side panel's two views: /regen opens it on regen - the spec, with how far the code has been regenerated into it
-    // - and /pulses on every pulse, regenerating, planned and finished, and what each regenerates. What the agents did is
-    // in each pulse's log.
-    for (const [name, description, view] of [
-        ["regen", `regen, in the side panel: every item of the spec, built, regenerating, planned or waiting. ${PANEL_KEY} opens the panel too.`, "map"],
-        ["pulses", `The pulses, in the side panel: every pulse, regenerating, planned and finished, and what each regenerates. ${PANEL_KEY} opens the panel too.`, "pulses"],
-    ]) {
-        pi.registerCommand(name, {
-            description,
-            handler: async (_args, ctx) => {
-                if (!ctx.hasUI)
-                    return;
-                openPanel(ctx, view);
-            },
-        });
-    }
+    // /pulses opens the side panel on every pulse, regenerating, planned and finished, and what each regenerates; regen -
+    // the spec, with how far the code has been regenerated into it - is PANEL_KEY's, no command of its own beside
+    // /regenerate. What the agents did is in each pulse's log.
+    pi.registerCommand("pulses", {
+        description: `The pulses, in the side panel: every pulse, regenerating, planned and finished, and what each regenerates. ${PANEL_KEY} opens the panel too.`,
+        handler: async (_args, ctx) => {
+            if (!ctx.hasUI)
+                return;
+            openPanel(ctx, "pulses");
+        },
+    });
     panelOpeners.set(jobs, (ctx) => openPanel(ctx));
     questionPeek = {
         open: (ctx) => openPanel(ctx),
-        shown: () => panel !== undefined,
+        shown: () => panel !== undefined && panel.keys,
     };
     pi.registerShortcut(PANEL_KEY, {
         description: "Peek at regen and the pulses - a question waiting in the chat waits for you - or go back to it",
@@ -1711,8 +1799,12 @@ export const JOB_FINISHED_REACTION = [
     "A pulse that stopped on its environment - \"stopped: turri's sandbox kept its agents from…\" or \"stopped: the",
     "environment lacks…\" - stops the same way again until that is fixed: never regenerate it before. Heal it, then regenerate the",
     "module to resume:",
-    "- turri's sandbox kept the agents from a folder on this machine: nothing is missing. Add the folder its report names to",
-    "  `toolchains:` in config.turri.yaml - a list, keeping what is there - say so in a line, and resume.",
+    "- turri's sandbox kept the agents from reading a folder on this machine: nothing is missing. Add the folder its report",
+    "  names to `toolchains:` in config.turri.yaml - a list, keeping what is there - say so in a line, and resume.",
+    "- turri's sandbox kept the agents from writing a file - a lock a build tool takes, say: no setting lets them, and",
+    "  `toolchains:` does not - never add it there, and never resume before the fix. Do what the report says if it is the",
+    "  project's to change - a tool told to use `$HOME` in the build's own files - say so, and resume; otherwise tell the",
+    "  person, in a line or two, what the report says and that \"resume\" picks it up once it is done.",
     "- the machine lacks a toolchain or a tool - a JDK, Maven, Gradle, Go, uv, Node, a system library: first find out, in your",
     "  shell, whether it is installed somewhere off the PATH (`command -v`, Homebrew's opt folders, /Library/Java/",
     "  JavaVirtualMachines, a version manager the person uses - mise, asdf, sdkman, nvm). Then ask the person with ask_user",
@@ -1724,6 +1816,8 @@ 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) {
@@ -2158,7 +2252,8 @@ function registerBranding(pi, ruleCount, skills) {
         if (data === undefined)
             return undefined;
         const lines = [
-            `${theme.fg("accent", "turri")}  ${theme.fg("muted", `v${data.version}`)}`,
+            `${theme.fg("accent", "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)` : "") +
@@ -2180,8 +2275,11 @@ function registerBranding(pi, ruleCount, skills) {
         if (ctx.hasUI)
             animateJellyfish(ctx);
         try {
+            const identity = turriIdentity();
             pi.appendEntry(BANNER_ENTRY, {
-                version: packageVersion(),
+                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,
@@ -2234,8 +2332,6 @@ function animateJellyfish(ctx) {
     }, { placement: "belowEditor" });
 }
 const JELLYFISH_CLOCK_KEY = "turri-jellyfish";
-/** What the banner puts between a row's text and the picture after it: back to the jellyfish's column. */
-const PICTURE_AT = "\x1b[2G";
 /** The columns the banner's picture takes from the left edge, while it shows one; 0 when it does not. */
 let pictureRight = 0;
 /**
@@ -2250,14 +2346,7 @@ function drawOverlaysBesidePicture(tui) {
         return;
     target.turriPicture = true;
     const original = target.compositeLineAt.bind(tui);
-    target.compositeLineAt = (base, overlay, col, width, total) => {
-        const at = base.lastIndexOf(PICTURE_AT);
-        const picture = at === -1 ? "" : base.slice(at + PICTURE_AT.length);
-        if (!/^(\x1b\[\d+A)?(\x1b_G|\x1b\]1337;File=)/.test(picture))
-            return original(base, overlay, col, width, total);
-        const drawn = compositeTuiLine(base.slice(0, at), overlay, col, width, total);
-        return col >= pictureRight ? `${drawn}${PICTURE_AT}${picture}` : drawn;
-    };
+    target.compositeLineAt = (base, overlay, col, width, total) => overPictureRow(base, overlay, col, width, total, pictureRight) ?? original(base, overlay, col, width, total);
 }
 /** Columns between the jellyfish and the lines beside it. */
 const JELLYFISH_GAP = 3;
@@ -2289,7 +2378,8 @@ class Banner {
         const art = this.art;
         const placed = art?.kind === "image" ? this.placeImage(art, Math.max(JELLYFISH_ROWS, this.lines.length), width - 2 - JELLYFISH_GAP - BANNER_TEXT_MIN) : art?.kind === "text" && art.columns <= width - 2 - JELLYFISH_GAP - BANNER_TEXT_MIN ? art : undefined;
         const left = placed !== undefined ? 1 + placed.columns + JELLYFISH_GAP : 1;
-        const text = this.lines.map((line) => truncateToWidth(line, Math.max(1, width - 1 - left)));
+        // Wrapped in the columns beside the picture, never cut short - the chat beside the docked panel is narrow.
+        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;
@@ -2361,12 +2451,3 @@ function jellyfishArt(appearance, ink) {
         return undefined;
     }
 }
-function packageVersion() {
-    try {
-        const raw = readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8");
-        return JSON.parse(raw).version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-}

package/dist/identity.js

@@ -25,7 +25,7 @@ export const TURRI_IDENTITY = [
     "- A pulse is one unit of work regenerating the code - a spec diff regenerated in a codebase, or its conformance",
     "  tests. It was called a job, and still is in places: the job_id a tool takes is a pulse's id, and parallel-jobs and",
     "  allow-to-stop-jobs in config.turri.yaml are about pulses. \"Job\" in what you read is a pulse; say pulse.",
-    "- regen is the side panel (/regen, or ctrl+h): the spec with each functionality and item marked built, regenerating,",
+    "- regen is the side panel (ctrl+h): the spec with each functionality and item marked built, regenerating,",
     "  planned or waiting - and behind it the pulses (/pulses), every pulse regenerating, planned and finished. Say regen,",
     "  lowercase. It was the regeneration, the job queue, or the job panel.",
     "- mutate, in a skill's activity, is write_spec_diff: a spec change written and regenerated in one step.",

package/dist/loop-tools.js

@@ -73,7 +73,7 @@ export async function loopReply(loop, statuses, wait) {
 export function stopJob(jobs, named, reason) {
     const matches = jobs.list().filter((job) => job.id.startsWith(named.trim()));
     if (matches.length === 0)
-        return `No pulse ${named}. /regen shows them.`;
+        return `No pulse ${named}. /pulses shows them.`;
     if (matches.length > 1)
         return `'${named}' matches ${matches.map((job) => job.id).join(", ")}. Give more of the id.`;
     const target = matches[0];

package/dist/pi-launch.js

@@ -9,19 +9,28 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { main, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { ProcessTerminal } from "@earendil-works/pi-tui";
 import "./terminal-images.js";
 /**
  * pi, started the way its own CLI starts it, for `turri`.
  *
- * The one difference: pi's startup header - its version, key hints and the list of every
- * loaded skill, extension and theme - is left out, because turri shows its own. pi only
- * takes that from the `quietStartup` setting, and a setting would quiet every `pi` on the
- * machine, so it is answered for this run instead. `--verbose` still shows it.
+ * What differs is pi's own branding, because turri shows its own: its startup header - its
+ * version, key hints and the list of every loaded skill, extension and theme - its update notice
+ * and its tab title. pi only takes the header from the `quietStartup` setting, and a setting would
+ * quiet every `pi` on the machine, so it is answered for this run instead. `--verbose` still shows it.
  */
 const args = process.argv.slice(2);
 if (!args.includes("--verbose")) {
     SettingsManager.prototype.getQuietStartup = () => true;
 }
+// pi's "Update Available" notice is left out: the pi turri runs is its pinned dependency, which `pi update`
+// does not touch - it moves when turri does.
+process.env.PI_SKIP_VERSION_CHECK = "1";
+// The terminal's tab title: pi writes `π - <folder>` (its APP_TITLE, a constant), turri a jellyfish and its name.
+const setTitle = ProcessTerminal.prototype.setTitle;
+ProcessTerminal.prototype.setTitle = function (title) {
+    setTitle.call(this, title.replace(/^π(?= |$)/, "🪼 turri"));
+};
 // pi's own keys stand: a new line is shift+enter or ctrl+j. turri's side panel is on ctrl+h (job-panel.ts PANEL_KEY).
 // What pi's CLI does before main: the process title, pi's environment markers, the HTTP
 // dispatcher. Not exported, so loaded from the file - beside pi's entry point, wherever npm put it.

package/dist/picture-row.js

@@ -0,0 +1,21 @@
+import { compositeTuiLine } from "@earendil-works/pi-tui";
+/** What the banner puts between a row's text and the picture after it: back to the jellyfish's column. */
+export const PICTURE_AT = "\x1b[2G";
+/** The picture's escape sequence, as the banner writes it after PICTURE_AT: Kitty's, in chunks, or iTerm2's - climbing first on iTerm2. */
+const PICTURE = /^(?:\x1b\[\d+A)?(?:(?:\x1b_G[^\x1b]*\x1b\\)+|\x1b\]1337;File=[^\x07]*\x07)/;
+/**
+ * The banner's picture row with an overlay drawn over its text, the picture after it - left out while the overlay
+ * reaches over the picture, `pictureRight` columns from the left edge. Undefined for a row that holds no picture.
+ *
+ * What follows the picture - the padding a row narrower than the screen is given, the chat's beside the docked panel -
+ * is the row's text: written after the picture, from the picture's column, it would blank the row.
+ */
+export function overPictureRow(base, overlay, col, width, total, pictureRight) {
+    const at = base.lastIndexOf(PICTURE_AT);
+    const picture = at === -1 ? null : PICTURE.exec(base.slice(at + PICTURE_AT.length));
+    if (picture === null)
+        return undefined;
+    const after = base.slice(at + PICTURE_AT.length + picture[0].length);
+    const drawn = compositeTuiLine(`${base.slice(0, at)}${after}`, overlay, col, width, total);
+    return col >= pictureRight ? `${drawn}${PICTURE_AT}${picture[0]}` : drawn;
+}

package/dist/regenerate/confine.js

@@ -188,6 +188,7 @@ export function sandboxNote(fence) {
         const report = fence.environmentTool !== undefined
             ? `report it as an environment error with ${fence.environmentTool}`
             : "say so plainly - what is missing and what needs it - and end your turn";
+        lines.push("- A command refused a file outside your folder - `Operation not permitted`, `Permission denied`, a lock it could not", `  take - is these walls, not the code, and nothing you change gets past them: ${report} at once, naming the file`, "  and the command that wanted it.");
         lines.push(fence.write.length > 0
             ? "- The project's dependencies are yours: declare them in the build manifest, and let the build tools fetch them."
             : "- You install nothing.", `${fence.write.length > 0 ? "  Installing anything else is not" : "  Nor is installing anything on the machine yours"}: no toolchains, system packages, drivers, global packages or \`sudo\`. If the`, `  machine lacks something the code needs, ${report}, name what is missing, and go no further with what depends on it.`, "  The person decides.", "- Ports and processes: you may stop only what you started. If a port is taken by something else, use another port.", "  `ps` may show nothing but what you started: check a server you started with `kill -0 $!`, its log, or a request to it.", "- Temporary files go in `$TMPDIR`: `/tmp` is outside your walls.");