@turri-dev/cli 0.1.3-next.26f08c5 → 0.1.3-next.420ce7e

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/config.js

@@ -189,8 +189,9 @@ export const ROLE_THINKING = {
     diagnosis: "medium",
 };
 /** The roles on the conversation's side: without their own entry they take the chat's model, not `default`. */
-// The release is not: it follows steps - a script, a start command - and runs on the coding model, thinking low.
-const CHAT_SIDE = ["chat", "chooser", "planner", "diagnosis"];
+// The release is not: it follows steps - a script, a start command - and runs on the coding model, thinking low. Nor
+// is the diagnosis: a post-mortem of a job that failed, read by the person - it runs on the coding model, thinking medium.
+const CHAT_SIDE = ["chat", "chooser", "planner"];
 function isThinkingLevel(value) {
     return typeof value === "string" && THINKING_LEVELS.includes(value);
 }

package/dist/extension.js

@@ -5,11 +5,11 @@ 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";
-import { AGENT_ROLES, CONFIG_FILE, configForSpec, hasProjectConfig, LEGACY_CONFIG_FILE, projectConfigFile, stackConfigFileIn, stackOf, stacksOf, withStack, modelSpec, projectModels, readProjectConfig, roleModel, splitModelSpec } from "./config.js";
+import { AGENT_ROLES, CONFIG_FILE, configForSpec, hasProjectConfig, LEGACY_CONFIG_FILE, projectConfigFile, stackConfigFileIn, stackOf, stacksOf, withStack, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, splitModelSpec } from "./config.js";
 import { skillRunDir } from "./regenerate/paths.js";
 import { sweepOrphanedGroups } from "./regenerate/shell.js";
 import { readScript, scriptAgainstMachine, stackOnMachine, toolchainsBlock } from "./stack.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";
@@ -88,15 +90,23 @@ aside) {
             // The question, with what the asker gives to read for it - a brief to confirm - above it; what it said of its work
             // before asking is kept in its record, never put in the dialog.
             // A dialog of turri's own: a long brief scrolls above the question, and the options always show (question-dialog.ts).
-            const dialog = (question, context, options) => ctx.ui.custom((tui, theme, _keybindings, done) => new QuestionDialog({
-                question,
-                ...(context !== undefined ? { context } : {}),
-                ...(options !== undefined ? { options } : {}),
-                rows: () => tui.terminal.rows,
-                style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
-                done,
-                requestRender: () => tui.requestRender(),
-            }));
+            const dialog = (question, context, options) => ctx.ui.custom((tui, theme, _keybindings, done) => {
+                const shown = new QuestionDialog({
+                    question,
+                    ...(context !== undefined ? { context } : {}),
+                    ...(options !== undefined ? { options } : {}),
+                    rows: () => 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)
+                            questionShown = undefined;
+                        done(answer);
+                    },
+                    requestRender: () => tui.requestRender(),
+                });
+                questionShown = shown;
+                return shown;
+            });
             const asking = (asked) => runAsk(asked, {
                 select: (title, options, context) => dialog(title, context, options),
                 input: (title, context) => dialog(title, context),
@@ -115,6 +125,12 @@ aside) {
 }
 /** The side panel, as a question open in the chat reaches it: set once the extension has its panel. */
 let questionPeek;
+/**
+ * The question open in the chat now, if any. The side panel gives the keys back to it: pi would give them to what had the
+ * focus when the panel first opened, and a panel kept beside the chat outlives that question - the keys would go to a
+ * dialog already answered, and nothing would take them.
+ */
+let questionShown;
 /** A widget with nothing to draw: below the editor, it takes no line. */
 const PEEK_KEY_WIDGET = "turri-peek-key";
 /**
@@ -184,7 +200,8 @@ export default function (pi) {
                 projectDir: cwd,
                 harnessDir: PACKAGE_ROOT,
                 jobLog,
-                model: modelSpec(projectModels(readProjectConfig(cwd)).harness),
+                // The coding model the job ran on - its model alone: the diagnosis thinks as its role has it.
+                model: modelSpec(modelOnly(job.model ?? modelSpec(projectModels(readProjectConfig(cwd)).coding))),
             });
             return diagnosis !== undefined ? describeDiagnosis(diagnosis) : undefined;
         },
@@ -1468,9 +1485,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,14 +1522,71 @@ function registerJobTools(pi, jobs, cwd) {
         }
         needsLooking.delete(jobs);
         if (panel !== undefined) {
+            panel.keepChatFocus();
             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);
+            // What the chat shows when the panel takes the keys - its editor, or a pi dialog - for when it gives them back.
+            const focusedNow = () => tui.getFocusedComponent?.() ?? null;
+            let chatFocus = focusedNow();
+            const keepChatFocus = () => {
+                const focused = focusedNow();
+                if (focused !== null && focused !== component && !(focused instanceof QuestionDialog))
+                    chatFocus = focused;
+            };
+            // The keys back to the chat: to the question open there now, else to what it showed - never to a question answered
+            // while the panel was open.
+            const giveBack = () => entry.handle?.unfocus({ target: questionShown ?? chatFocus });
+            const close = () => {
+                giveBack();
+                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;
+                giveBack();
+                tui.requestRender();
+            };
+            const toPanel = () => {
+                keepChatFocus();
+                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({
@@ -1514,6 +1596,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),
@@ -1528,22 +1618,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, keepChatFocus, 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.
@@ -1565,6 +1658,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.
@@ -1591,7 +1700,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))
@@ -1607,6 +1722,7 @@ function registerJobTools(pi, jobs, cwd) {
                 dispose: () => {
                     unlisten();
                     clearInterval(timer);
+                    undock?.();
                     if (panel === entry)
                         panel = undefined;
                 },
@@ -1614,34 +1730,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",
@@ -1712,8 +1830,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",
@@ -1725,6 +1847,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) {
@@ -2239,8 +2363,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;
 /**
@@ -2255,14 +2377,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;
@@ -2294,7 +2409,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;

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-cli.js

@@ -69,7 +69,7 @@ async function runLoopReporting(options) {
     const registry = createJobRegistry({
         retries: 1,
         diagnose: async (job, failures, jobLog) => {
-            const diagnosis = await diagnoseFailure({ job, failures, projectDir, harnessDir: PACKAGE_ROOT, jobLog, model: modelSpec(projectModels(project).harness) ?? model });
+            const diagnosis = await diagnoseFailure({ job, failures, projectDir, harnessDir: PACKAGE_ROOT, jobLog, model: modelSpec(modelOnly(job.model ?? model)) });
             return diagnosis !== undefined ? describeDiagnosis(diagnosis) : undefined;
         },
         onChange: (job) => {

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

@@ -11,6 +11,7 @@ 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";
+import { resumeLine } from "./resume-line.js";
 /**
  * pi, started the way its own CLI starts it, for `turri`.
  *
@@ -31,6 +32,10 @@ const setTitle = ProcessTerminal.prototype.setTitle;
 ProcessTerminal.prototype.setTitle = function (title) {
     setTitle.call(this, title.replace(/^π(?= |$)/, "🪼 turri"));
 };
+// What pi prints on the way out to resume the session names pi - its APP_NAME, a constant - which may not be on the
+// PATH at all: turri takes the same flags, so it is turri the line names.
+const write = process.stdout.write.bind(process.stdout);
+process.stdout.write = ((chunk, ...rest) => write(typeof chunk === "string" ? resumeLine(chunk) : chunk, ...rest));
 // 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/question-dialog.js

@@ -58,18 +58,23 @@ export class QuestionDialog {
         const choices = this.options.options ?? [];
         const body = this.input !== undefined
             ? this.input.render(inner)
-            : choices.map((choice, index) => (index === this.selected ? style.accent(`› ${choice}`) : `  ${choice}`));
+            : // A long option wraps, its lines under its first, rather than cut off where the person cannot read it.
+                choices.flatMap((choice, index) => wrapTextWithAnsi(choice, Math.max(1, inner - 2)).map((line, at) => {
+                    const shown = `${at === 0 && index === this.selected ? "›" : " "} ${line}`;
+                    return index === this.selected ? style.accent(shown) : shown;
+                }));
         const hint = this.input !== undefined
             ? "enter answers · esc dismisses"
             : "↑↓ choose · enter picks · esc dismisses";
         // The brief gets what the question, the options and the hints leave of the screen.
-        const fixed = question.length + body.length + 4;
+        const fixed = question.length + body.length + 5;
         const room = Math.max(3, this.options.rows() - KEPT_ABOVE - fixed);
         const scrolls = brief.length > room;
         this.window = scrolls ? room - 1 : brief.length;
         this.maxScroll = scrolls ? brief.length - this.window : 0;
         this.scroll = Math.min(this.scroll, this.maxScroll);
-        const lines = [];
+        // Set apart from what is drawn above it - the job panel's hints.
+        const lines = [""];
         if (brief.length > 0) {
             lines.push(...brief.slice(this.scroll, this.scroll + this.window).map(pad));
             if (scrolls) {

package/dist/questioning.js

@@ -43,7 +43,7 @@ export function questioningQuestion(phases) {
     return {
         question: `How many questions should I ask you in ${named}?`,
         options: QUESTIONING_LEVELS.map((level) => level.option),
-        context: `Light, medium and thorough cap each of ${named} at 3, 5 and 10 questions - broader with fewer, so every level ` +
+        context: `Light, medium and thorough cap ${phases.length === 1 ? named : `each of ${named}`} at 3, 5 and 10 questions - broader with fewer, so every level ` +
             "covers the same ground, only in less or more depth. What the questions leave open, turri decides itself and " +
             "says what it chose. With best judgement, turri asks as much as it judges each phase needs. Each phase still " +
             "ends with your confirmation of its summary.",

package/dist/regenerate/activity.js

@@ -183,6 +183,8 @@ export function describeToolCall(name, args) {
             return `± my_diff`;
         case "update_notes":
             return `✐ update_notes`;
+        case "report_spec_gap":
+            return `? spec gap: ${text("question") ?? ""}`.trimEnd();
         case "copy_resource":
             return `⎘ copy_resource ${path ?? text("to") ?? ""}`.trimEnd();
         case "can_it_fail":

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.");

package/dist/regenerate/conform.js

@@ -7,7 +7,7 @@ import { abandonWork, startWork } from "./lineage.js";
 import { ensureRegressionPasses } from "./regression.js";
 import { modulesRoot, projectDirOf } from "./paths.js";
 import { applySpecDiff, snapshotSpec, specGapsText } from "./regenerate.js";
-import { linesAddedSince, readNotes } from "./notes.js";
+import { gapMark, gapsSince } from "./notes.js";
 import { sectionsOf } from "./state.js";
 import { describeStop } from "./stop-report.js";
 import { missingTestLabels } from "./test-kinds.js";
@@ -41,8 +41,8 @@ export async function renderSpecDiffConformance(options) {
     // state, not to what an interrupted run left half-written. The tests and the whole suite are
     // one unit, landed whole or undone whole.
     const unit = startWork([buildDir, conformanceDir], moduleName);
-    // The notes as its agents find them: a spec gap they add is told with the result.
-    const notesBefore = { code: readNotes(buildDir), tests: readNotes(conformanceDir) };
+    // The spec gaps its agents report from here on are told with the result.
+    const gapsFrom = gapMark();
     const conformance = await renderConformanceTests({
         plainFile: tip.plainFile,
         frid: lastFrid,
@@ -58,8 +58,8 @@ export async function renderSpecDiffConformance(options) {
     });
     // What the codebase now has conformance tests for, as their labels say.
     const tested = () => frids.filter((frid) => missingTestLabels(conformanceDir, frid, []).length === 0);
-    // Read before a rollback takes the notes back: a gap is the person's to decide, whether the tests passed or not.
-    const base = { moduleName, buildDir, conformanceDir, diff: applied, conformance, specGaps: [...linesAddedSince(notesBefore.code, buildDir, "gaps"), ...linesAddedSince(notesBefore.tests, conformanceDir, "gaps")] };
+    // A gap is the person's to decide, whether the tests passed or not.
+    const base = { moduleName, buildDir, conformanceDir, diff: applied, conformance, specGaps: gapsSince(gapsFrom, [buildDir, conformanceDir]) };
     if (!conformance.passed) {
         abandonWork(unit, moduleName, notLandedWhy("for the spec change", conformance.unlabelled));
         return { ...base, tested: tested(), passed: false, stoppedAt: "conformance" };