@turri-dev/cli 0.1.18-next.85984f7 → 0.1.19-next.ee6bc61

package/dist/chat-terminal.js

@@ -1,4 +1,5 @@
 import { AgentSessionRuntime, InteractiveMode, SessionManager } from "@earendil-works/pi-coding-agent";
+import { showWaitingMessages } from "./chat-waiting.js";
 import { interruptChat, terminalUi } from "./chats.js";
 /**
  * ctrl+c, in the chat shown: what it is doing stopped, the other chats left as they are (`interruptChat`). In a chat
@@ -34,6 +35,8 @@ export function driveTerminal(core, options = {}) {
         ui.show(real);
         runner.setUIContext(ui.ui, runner.mode);
         catchUp(session);
+        // What the chat shown was sent while its agent worked, and has not read yet: in its chat, shaded.
+        screen?.updatePendingMessagesDisplay?.();
         core.showing(chat);
         // The run `--continue` reopens: its first chat is pi's own, the rest are opened beside it.
         if (restore !== undefined) {
@@ -54,6 +57,7 @@ export function driveTerminal(core, options = {}) {
         if (writing !== undefined && writing.role === "assistant")
             void screen.handleEvent({ type: "message_start", message: writing });
     };
+    showWaitingMessages();
     const prototype = InteractiveMode.prototype;
     const rebind = prototype.rebindCurrentSession;
     prototype.rebindCurrentSession = async function (...args) {

package/dist/chat-waiting.d.ts

@@ -0,0 +1,64 @@
+import { type Component } from "@earendil-works/pi-tui";
+/**
+ * A message sent while the chat's agent works, shown as a message at once: pi queues it until the agent's turn reaches
+ * a point it can read it - the end of a step, which a long tool call holds off for minutes - and until then lists it
+ * only as a dim `Steering:` line under the chat. Here each message waiting is drawn there as the message it is,
+ * shaded and marked not read yet - under the chat, so it stays below what the agent writes and the tools it calls
+ * meanwhile. When the agent reads it, it leaves the queue and pi puts it in the chat, a normal message, where it was
+ * read. Taken back into the editor (pi's dequeue, esc, ctrl+c), it goes with the queue.
+ *
+ * pi has no hook for it: its screen is patched, as chat-terminal.ts patches it - tests/chat-terminal.test.ts checks
+ * what it reaches against the pi installed.
+ */
+/** What of pi's interactive mode this reaches: its own fields and methods, in plain JavaScript. */
+export interface WaitingScreen {
+    chatContainer: Container;
+    pendingMessagesContainer: Container;
+    getAllQueuedMessages(): {
+        steering: string[];
+        followUp: string[];
+    };
+    addMessageToChat(message: unknown, options?: unknown): void;
+    getAppKeyDisplay?(action: string): string;
+}
+interface Container {
+    children: Component[];
+    addChild(component: Component): void;
+    clear(): void;
+}
+/** A part of a message waiting to be read, drawn shaded - with, under the last part, what it is waiting for. */
+export declare class Shade implements Component {
+    inner: Component;
+    note: string;
+    constructor(inner: Component, note?: string);
+    render(width: number): string[];
+    invalidate(): void;
+}
+/**
+ * Under the chat, each message the agent has not read yet, drawn as pi draws a message in the chat - shaded, and
+ * marked not read yet - in the order they were sent.
+ */
+export declare function showWaiting(screen: WaitingScreen): void;
+/** What of pi's session `unqueue` reaches. */
+export interface QueueOf {
+    getSteeringMessages(): readonly string[];
+    getFollowUpMessages(): readonly string[];
+    clearQueue(): {
+        steering: string[];
+        followUp: string[];
+    };
+    steer(text: string, images?: undefined, options?: {
+        source: "extension";
+    }): Promise<unknown>;
+    followUp(text: string, images?: undefined, options?: {
+        source: "extension";
+    }): Promise<unknown>;
+}
+/**
+ * A message taken out of the session's queue - read by another agent, a skill's - the rest put back as they were, in
+ * order. pi takes none out alone: the queue is emptied and filled again. False when it is not queued.
+ */
+export declare function unqueue(session: QueueOf, text: string): Promise<boolean>;
+/** pi's screen patched, once: the messages waiting for the agent drawn under the chat as messages, shaded. */
+export declare function showWaitingMessages(): void;
+export {};

package/dist/chat-waiting.js

@@ -0,0 +1,86 @@
+import { InteractiveMode } from "@earendil-works/pi-coding-agent";
+import { Spacer, truncateToWidth } from "@earendil-works/pi-tui";
+const DIM = "\x1b[2m";
+const UNDIM = "\x1b[22m";
+/** A part of a message waiting to be read, drawn shaded - with, under the last part, what it is waiting for. */
+export class Shade {
+    inner;
+    note;
+    constructor(inner, note = "") {
+        this.inner = inner;
+        this.note = note;
+    }
+    render(width) {
+        // Dim kept on past every reset in a line: a bold word or a colour must not end the shade.
+        const lines = this.inner.render(width).map((line) => `${DIM}${line.replace(/\x1b\[(?:0|22)?m/g, (reset) => `${reset}${DIM}`)}${UNDIM}`);
+        return this.note === "" ? lines : [...lines, `${DIM}${truncateToWidth(` ${this.note}`, width)}${UNDIM}`];
+    }
+    invalidate() {
+        this.inner.invalidate();
+    }
+}
+/**
+ * Under the chat, each message the agent has not read yet, drawn as pi draws a message in the chat - shaded, and
+ * marked not read yet - in the order they were sent.
+ */
+export function showWaiting(screen) {
+    const area = screen.pendingMessagesContainer;
+    area.clear();
+    const { steering, followUp } = screen.getAllQueuedMessages();
+    const waiting = [...steering, ...followUp];
+    if (waiting.length === 0)
+        return;
+    const key = screen.getAppKeyDisplay?.("app.message.dequeue");
+    const note = `not read yet${key !== undefined && key !== "" ? ` · ${key} to edit` : ""}`;
+    // Drawn by pi's own drawing of a message in the chat, into the area under it instead.
+    const chat = screen.chatContainer;
+    screen.chatContainer = area;
+    try {
+        for (const text of waiting) {
+            // A line between it and the chat; pi puts one between messages itself.
+            if (area.children.length === 0)
+                area.addChild(new Spacer(1));
+            const before = area.children.length;
+            screen.addMessageToChat({ role: "user", content: [{ type: "text", text }], timestamp: Date.now() });
+            const parts = area.children.slice(before);
+            parts.forEach((part, index) => {
+                if (part instanceof Spacer)
+                    return;
+                area.children[before + index] = new Shade(part, index === parts.length - 1 ? note : "");
+            });
+        }
+    }
+    finally {
+        screen.chatContainer = chat;
+    }
+}
+/**
+ * A message taken out of the session's queue - read by another agent, a skill's - the rest put back as they were, in
+ * order. pi takes none out alone: the queue is emptied and filled again. False when it is not queued.
+ */
+export async function unqueue(session, text) {
+    if (!session.getSteeringMessages().includes(text) && !session.getFollowUpMessages().includes(text))
+        return false;
+    const { steering, followUp } = session.clearQueue();
+    const at = steering.indexOf(text);
+    if (at !== -1)
+        steering.splice(at, 1);
+    else
+        followUp.splice(followUp.indexOf(text), 1);
+    // Put back as turri's, not typed: what watches the person's input does not take them again.
+    for (const message of steering)
+        await session.steer(message, undefined, { source: "extension" });
+    for (const message of followUp)
+        await session.followUp(message, undefined, { source: "extension" });
+    return true;
+}
+/** pi's screen patched, once: the messages waiting for the agent drawn under the chat as messages, shaded. */
+export function showWaitingMessages() {
+    const prototype = InteractiveMode.prototype;
+    if (prototype.turriWaiting === true)
+        return;
+    prototype.turriWaiting = true;
+    prototype.updatePendingMessagesDisplay = function () {
+        showWaiting(this);
+    };
+}

package/dist/chats.d.ts

@@ -69,6 +69,8 @@ export interface ChatLink {
     readonly scope: ChatScope;
     /** The host's dialogs, for this chat's questions - undefined in the terminal. */
     readonly dialogs: AskUserIO | undefined;
+    /** Its pi session, once it has one. */
+    session(): AgentSession | undefined;
     /** The extension built for the chat - again, when pi rebuilds it - and what it does for it. */
     live(instance: ChatInstance): void;
 }

package/dist/chats.js

@@ -287,6 +287,7 @@ export function createChats(options) {
                 id: chat.id,
                 scope: chat.scope,
                 dialogs: chat.dialogs,
+                session: () => chat.session,
                 live: (instance) => {
                     chat.instance = instance;
                 },

package/dist/extension.js

@@ -6,7 +6,7 @@ import { basename, dirname, join, relative, resolve } from "node:path";
 import { conversationCommand, conversationSettled, conversationWriting } from "./regenerate/conversation-writes.js";
 import { fileURLToPath } from "node:url";
 import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease, isKeyRepeat, matchesKey, renderImage, Text, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { defineTool } from "@earendil-works/pi-coding-agent";
+import { defineTool, getMarkdownTheme, UserMessageComponent } 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, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, splitModelSpec } from "./config.js";
@@ -19,6 +19,7 @@ import { createAskUserTool } from "./tools.js";
 import { asksFromScratch, asksWholeChain, driftTool, fromWorkingDir, haltTool, loopReply, MODEL_PARAM, regenerateTool, STACK_PARAM, stopJob, WAIT_PARAM, withCallStack, WORKING_DIR_PARAM } from "./loop-tools.js";
 import { createWebTools } from "./regenerate/web.js";
 import { describeGates, interruptedRun, runSkill } from "./genome.js";
+import { unqueue } from "./chat-waiting.js";
 import { skillStatus } from "./skill.js";
 import { runningDeployed, stopDeployed } from "./regenerate/release.js";
 import { createDeployState, createDeployTools } from "./release-tools.js";
@@ -479,9 +480,15 @@ function turriExtension(api, session, link) {
     // The conversation's agent does not run turri again through its shell, unless the person
     // asked for the command line in the message it is answering.
     let lastUserMessage = "";
+    /** While a skill runs in this chat: what passes the person's message to its agent. */
+    let skillMessage;
     pi.on("input", (event) => {
         if (event.source !== "extension")
             lastUserMessage = event.text;
+        // A skill running in this chat holds its agent for the whole run: what the person types meanwhile is for the
+        // skill's agent. It stays queued here too, shown waiting, until that agent reads it - or, the run over first, this one.
+        if (event.source === "interactive" && skillMessage !== undefined && !event.text.startsWith("/"))
+            skillMessage(event.text);
         return { action: "continue" };
     });
     pi.on("tool_call", (event) => {
@@ -658,6 +665,22 @@ function turriExtension(api, session, link) {
             }
             // Its command is used up: started again later, it is typed again.
             gate.started(skill.name);
+            // What the person said to it while it ran, its agent having read it: told to this chat's agent with the result.
+            const heard = [];
+            const messages = {
+                open: (tell) => {
+                    skillMessage = tell;
+                },
+                read: (text) => {
+                    heard.push(text);
+                    const session = link.session();
+                    // Read by the skill's agent, not this one: out of this chat's queue, and into its chat where it was read.
+                    void (session !== undefined ? unqueue(session, text) : Promise.resolve(false)).then((taken) => {
+                        if (taken)
+                            pi.appendEntry(SKILL_MESSAGE_ENTRY, { text, skill: skill.name });
+                    });
+                },
+            };
             const trace = [`skill: ${skill.name}`, ...describeGates(skill).map((l) => `  ${l}`)];
             // While it runs, what its agent is doing leads: pi shows a running tool's first lines, and the trace's first
             // lines are the gates, which say nothing about now. The result keeps the trace alone.
@@ -754,6 +777,7 @@ function turriExtension(api, session, link) {
                 resume: params.resume === true && interrupted !== undefined,
                 report,
                 context: conversationContext(ctx, params.context),
+                messages,
                 askUser: askUserVia(ctx, (question, answer, said) => {
                     // What the skill's agent said before asking stays in the run's record, not only in the dialog.
                     for (const line of (said ?? "").trim().split("\n").filter((line) => line.trim() !== ""))
@@ -835,12 +859,14 @@ function turriExtension(api, session, link) {
                 ? ""
                 : `Time to first regeneration: ${formatElapsed(first.started)} - its first pulse started that long after ${skill.name} began` +
                     (first.landed !== undefined ? `, and landed after ${formatElapsed(first.landed)}.` : ".");
+            const said = heard.length > 0 ? ["", `While it ran, the person said to it - its agent read and acted on each:`, ...heard.map((text) => `- ${text.replace(/\s+/g, " ").trim()}`)] : [];
             const text = result.ok
                 ? [
                     gated ? `${skill.name}: passed all gates.` : `${skill.name}: finished. It has no review gates, so nothing checked its work: read what it changed before you report it.`,
                     changed,
                     ...(unrendered !== "" ? [unrendered] : []),
                     ...(ttfr !== "" ? [ttfr] : []),
+                    ...said,
                     "",
                     "<artifact>",
                     result.output,
@@ -850,7 +876,7 @@ function turriExtension(api, session, link) {
                     ...trace,
                     "</trace>",
                 ].join("\n")
-                : [`${skill.name}: stopped at a gate. No approved artifact.`, changed, "", "<trace>", ...trace, "</trace>"].join("\n");
+                : [`${skill.name}: stopped at a gate. No approved artifact.`, changed, ...said, "", "<trace>", ...trace, "</trace>"].join("\n");
             return { content: [{ type: "text", text }], details: { ok: result.ok, artifacts: result.artifacts } };
         },
     });
@@ -2338,6 +2364,8 @@ function registerSteering(pi, cwd) {
  * started is stopped when the session ends.
  */
 const SIDE_ENTRY = "turri_btw";
+/** A message the person sent while a skill ran in the chat, read by the skill's agent: drawn as the message it is. */
+const SKILL_MESSAGE_ENTRY = "turri_skill_message";
 /**
  * /btw, a question on the side (btw.ts): answered at once, even while a skill runs - pi runs a command mid-turn - and
  * shown in the transcript, never in a model's context.
@@ -2365,6 +2393,12 @@ function registerSideQuestions(pi, cwd, jobs) {
         box.addChild(new Text(lines.join("\n"), 0, 0));
         return box;
     });
+    pi.registerEntryRenderer(SKILL_MESSAGE_ENTRY, (entry) => {
+        const data = entry.data;
+        if (data === undefined)
+            return undefined;
+        return new UserMessageComponent(data.text, getMarkdownTheme());
+    });
     pi.registerEntryRenderer(SIDE_ENTRY, (entry, _options, theme) => {
         const data = entry.data;
         if (data === undefined)

package/dist/genome.d.ts

@@ -17,6 +17,16 @@ export interface RunSkillResult {
     /** The last step's artifact - what the caller usually wants. */
     output: string;
 }
+/**
+ * The person's messages to a run while it works - typed in the chat the skill was started from, whose own agent is busy
+ * running it: each is given to the run's agent, and `read` is told when that agent reads it.
+ */
+export interface SkillMessages {
+    /** Given what passes a message to the run's agent as the run starts, and undefined as it ends. */
+    open(tell: ((text: string) => void) | undefined): void;
+    /** The run's agent read a message passed to it. */
+    read(text: string): void;
+}
 export interface RunSkillOptions {
     skillDir: string;
     cwd: string;
@@ -26,6 +36,8 @@ export interface RunSkillOptions {
     escalate: (request: EscalationRequest) => Promise<boolean>;
     /** Lets a step interview the user. Omitted: the skill runs with nobody to ask. */
     askUser?: AskUser;
+    /** What the person says in the chat while it runs, for its agent. */
+    messages?: SkillMessages;
     /** "provider/model-id" for the executor and the judges. Omitted: pi's default. */
     model?: string;
     /** Lets steps build functionalities in the background while the interview continues. */

package/dist/genome.js

@@ -156,8 +156,20 @@ async function runStoppable(opts) {
         attempts: {},
         updatedAt: "",
     };
+    // The person's messages, given to the agent at its next step - or with its next prompt, between steps.
+    const passed = [];
     // What the agent does, as it does it: its session is its own, so without this a long step is silence.
     executor.subscribe((event) => {
+        if (event.type === "message_start" && event.message.role === "user") {
+            const content = event.message.content;
+            const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter((part) => part?.type === "text").map((part) => part.text).join("") : "";
+            const at = passed.indexOf(text);
+            if (at !== -1) {
+                passed.splice(at, 1);
+                opts.messages?.read(text);
+            }
+            return;
+        }
         if (event.type === "tool_execution_start") {
             opts.report.activity?.(describeToolCall(event.toolName, event.args));
             return;
@@ -212,6 +224,10 @@ async function runStoppable(opts) {
         liveReviewers.set(liveStep.name, liveProxy);
     }
     try {
+        opts.messages?.open((text) => {
+            passed.push(text);
+            void Promise.resolve(executor.steer(text, undefined, { source: "extension" })).catch(() => undefined);
+        });
         const app = compileSkill({
             skill,
             cwd: opts.cwd,
@@ -265,6 +281,7 @@ async function runStoppable(opts) {
         };
     }
     finally {
+        opts.messages?.open(undefined);
         executor.dispose();
     }
 }

package/dist/new-project.js

@@ -10,7 +10,7 @@ export const NEW_PROJECT = [
     "and there is no ***plain module for it yet, or they ask for a new project, ask them first how to start it, with",
     "ask_user: one question, these three options, word for word, so they know the skills are there:",
     `- "${"/brood - an interview: the stack, the testing and every feature settled with you, each answer regenerated"}"`,
-    `- "${"/spawn - something running in minutes: the quick start, asking only what your message leaves open"}"`,
+    `- "${"/spawn - something running in minutes: the quick start, asking the stack in one question unless your message names it"}"`,
     `- "${"Just do it - no skill: I write it here and start regenerating"}"`,
     "Picked /brood or /spawn: the answer starts it - call cultivate for it at once, with what they said as its context,",
     "never asking them to type its command. Do not ask when their",

package/dist/pi-launch.js

@@ -11,7 +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";
+import { withoutResumeLine } from "./resume-line.js";
 import { lastRun } from "./chat-records.js";
 import { driveTerminal } from "./chat-terminal.js";
 import turri, { createTurriCore, processSession } from "./extension.js";
@@ -37,10 +37,13 @@ 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.
+// Leaving turri leaves the terminal as it was, the command run its only trace. pi's fullscreen screen - its default -
+// writes the conversation out to the terminal on the way out, unless its `fullscreenExitOutput` is `resume-hint`, which
+// is answered for this run as `quietStartup` is; the line it prints instead, to resume the session, is left out too:
+// `turri --continue` opens the last run again.
+SettingsManager.prototype.getFullscreenExitOutput = () => "resume-hint";
 const write = process.stdout.write.bind(process.stdout);
-process.stdout.write = ((chunk, ...rest) => write(typeof chunk === "string" ? resumeLine(chunk) : chunk, ...rest));
+process.stdout.write = ((chunk, ...rest) => write(typeof chunk === "string" ? withoutResumeLine(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/regenerate/conformance-agents.d.ts

@@ -213,7 +213,7 @@ export declare function testReviewRequest(options: {
 }): string;
 /** The review's problems, for the conformance agent to fix. */
 export declare function reviewFeedbackPrompt(problems: ReviewProblem[]): string;
-export type Culprit = "code" | "tests" | "spec" | "environment";
+export type Culprit = "code" | "tests" | "spec" | "environment" | "script";
 /** One thing the judge found, and where: a file it opened, `testing script`, or `failing run`. */
 export interface Evidence {
     source: string;
@@ -394,10 +394,14 @@ export declare function escalatedFixPrompt(options: {
         content: string;
     }>;
 }): string;
-/** The run's environment judged what is wrong: the conformance agent checks the tests do not cause it, and changes nothing when they do not. */
+/**
+ * The run's environment, or the testing script itself, judged what is wrong: the conformance agent checks the tests do
+ * not cause it, and changes nothing when they do not.
+ */
 export declare function environmentCheckPrompt(options: {
     run: ScriptRun;
     reason: string;
+    culprit?: "environment" | "script";
 }): string;
 export declare function testsFixPrompt(options: {
     run: ScriptRun;

package/dist/regenerate/conformance-agents.js

@@ -729,10 +729,10 @@ export async function judgeFailure(options) {
     const submit = defineTool({
         name: "submit_verdict",
         label: "Submit verdict",
-        description: "Say what is wrong - the code, the tests, the specification itself, or the run's environment - and why. Call this exactly once.",
+        description: "Say what is wrong - the code, the tests, the specification itself, the run's environment or the testing script - and why. Call this exactly once.",
         parameters: Type.Object({
-            culprit: Type.Union([Type.Literal("code"), Type.Literal("tests"), Type.Literal("spec"), Type.Literal("environment")], {
-                description: "What has to change to meet the specification - or spec, when the specification cannot be met at all, or environment, when only the person can fix what the run is given",
+            culprit: Type.Union([Type.Literal("code"), Type.Literal("tests"), Type.Literal("spec"), Type.Literal("environment"), Type.Literal("script")], {
+                description: "What has to change to meet the specification - or spec, when the specification cannot be met at all, environment, when only the person can fix what the run is given, or script, when the testing script itself fails whatever the code and the tests are",
             }),
             reason: Type.String({ description: "Why, against the specification: which test, which behaviour, what the spec says" }),
             spec_says: Type.Optional(Type.String({
@@ -800,7 +800,7 @@ export async function judgeFailure(options) {
         await ask(session, BEGIN, options.onDelta);
         for (let again = 0; again < 2; again += 1) {
             if (verdict === undefined) {
-                await ask(session, "You have not called submit_verdict. Call it now: code, tests, spec or environment, and why.", options.onDelta);
+                await ask(session, "You have not called submit_verdict. Call it now: code, tests, spec, environment or script, and why.", options.onDelta);
                 continue;
             }
             // Asked to weigh an escalation, a verdict of code or tests rests on what it found itself.
@@ -861,7 +861,7 @@ export function judgePrompt(options) {
     const scripts = options.testingScripts ?? [];
     return [
         specPrimer({ testReqs: true }),
-        `The conformance tests of the \`${options.spec.moduleName}\` specification failed. Decide what is wrong: the code, the tests, the specification itself, or the run's environment.`,
+        `The conformance tests of the \`${options.spec.moduleName}\` specification failed. Decide what is wrong: the code, the tests, the specification itself, the run's environment, or the testing script.`,
         "",
         `The code is in ${options.buildDir}; the conformance tests are in ${options.conformanceDir}. Read both.`,
         "",
@@ -889,10 +889,17 @@ export function judgePrompt(options) {
         "  make up), an account, plan or quota a service refuses, a service the specification names that cannot be reached",
         "  at all. Say what the person has to provide, and where the run read it from - the file, the variable. Not for what",
         "  the tests set up themselves - a credential, a variable or a fixture a test sets, overrides or names wrong: that is",
-        "  tests; nor for a toolchain or package missing where the tests run: the agents install those. The run stops on it",
-        `  once it has been judged so ${ENVIRONMENT_RAISES} times in a row; until then the tests are checked for whether they cause it.`,
+        "  tests; nor for a package the code or the tests can declare: the agents add those. An interpreter or a toolchain",
+        "  this machine lacks - `python`, `node` - is environment: the testing scripts run on this machine, and only the",
+        `  person installs on it. The run stops on it once it has been judged so ${ENVIRONMENT_RAISES} times in a row; until then`,
+        "  the tests are checked for whether they cause it.",
         "  A run the time limit stopped is environment only when nothing hangs and it needs more time than a test run may",
         "  take - and then it stops at once.",
+        "- script: the conformance testing script, or the prepare script, is itself wrong - it fails whatever the code and the",
+        "  tests are: it overwrites the tests' exit code, runs the wrong folder, calls a tool wrongly. Neither agent may change",
+        "  it - only the person can. Only when no code and no tests could pass it: what the script needs of the build is code,",
+        "  and how the tests are reached is tests. Quote its lines in evidence and say what to change in it. It counts as",
+        `  environment does: once judged so ${ENVIRONMENT_RAISES} times in a row, the run stops.`,
         "",
         "When the output does not show why the software failed - it answered with an error that names no cause, and",
         "logged nothing about it - the code is what is wrong first: it hides the cause, and nobody can fix what they",
@@ -1124,12 +1131,22 @@ export function escalatedFixPrompt(options) {
         "if the run still fails the same way after your fix, the work stops.",
     ].join("\n");
 }
-/** The run's environment judged what is wrong: the conformance agent checks the tests do not cause it, and changes nothing when they do not. */
+/**
+ * The run's environment, or the testing script itself, judged what is wrong: the conformance agent checks the tests do
+ * not cause it, and changes nothing when they do not.
+ */
 export function environmentCheckPrompt(options) {
     return [
         `The harness ran the conformance testing script, \`${options.run.command}\`, on the whole suite, and it failed (exit ${options.run.exitCode}).`,
-        "It was checked against the specification, and what is wrong is judged to be the run's environment - something only",
-        "the person can fix, such as a credential the run is given:",
+        ...(options.culprit === "script"
+            ? [
+                "It was checked against the specification, and what is wrong is judged to be the conformance testing script itself -",
+                "it fails whatever the code and the tests are, and only the person can change it:",
+            ]
+            : [
+                "It was checked against the specification, and what is wrong is judged to be the run's environment - something only",
+                "the person can fix, such as a credential the run is given:",
+            ]),
         "",
         `<why the environment>\n${options.reason.trim()}\n</why the environment>`,
         "",
@@ -1137,10 +1154,19 @@ export function environmentCheckPrompt(options) {
         options.run.output.trimEnd().slice(-6000),
         "</failing run>",
         "",
-        "Before that is taken as the answer, check that the tests do not cause it themselves: a credential, an environment",
-        "variable or a fixture a test sets, overrides, leaves behind for the next test, or reads under the wrong name. If",
-        "they do, fix the tests and run them. If they do not, change nothing - never make up a credential, write a .env",
-        "file, or weaken a test so it passes without what it needs - and say so in submit_work.",
+        ...(options.culprit === "script"
+            ? [
+                "Before that is taken as the answer, check that the tests do not cause it themselves: tests in a folder, under a",
+                "name or for a runner the script does not take, a test that fails for its own reasons. If they do, fix the tests",
+                "and run them. If they do not, change nothing - never weaken a test, or work around the script - and say so in",
+                "submit_work.",
+            ]
+            : [
+                "Before that is taken as the answer, check that the tests do not cause it themselves: a credential, an environment",
+                "variable or a fixture a test sets, overrides, leaves behind for the next test, or reads under the wrong name. If",
+                "they do, fix the tests and run them. If they do not, change nothing - never make up a credential, write a .env",
+                "file, or weaken a test so it passes without what it needs - and say so in submit_work.",
+            ]),
     ].join("\n");
 }
 export function testsFixPrompt(options) {

package/dist/regenerate/conformance.d.ts

@@ -95,14 +95,6 @@ export interface RenderConformanceTestsResult {
         times: number;
         changedNothing?: boolean;
     };
-    /**
-     * The run's environment is what is wrong - a credential missing or rejected, say - judged so ENVIRONMENT_RAISES
-     * times in a row: only the person can fix it, so the run stopped.
-     */
-    environment?: {
-        reason: string;
-        times: number;
-    };
     /**
      * The tests' fix for a failure did not make it go away, the judge found it the code's and escalated it to the coding
      * agent - and the run still failed the same way after the code's fix too: why the judge found it the code's, on what

package/dist/regenerate/conformance.js

@@ -15,7 +15,7 @@ import { createScriptTool, findTestScripts, projectRootFor, requireTestScripts,
 import { createWebTools, WEB_TOOLS } from "./web.js";
 import { createMyDiffTool } from "./self-check.js";
 import { createServiceTools } from "./services.js";
-import { missingToolchainError, timeLimitError, toolchainError } from "./environment-error.js";
+import { missingToolchainError, runEnvironmentError, scriptFaultError, timeLimitError, toolchainError } from "./environment-error.js";
 import { workspaceBlock } from "./workspace.js";
 import { codeFixPrompt, conflictKey, escalatedFixPrompt, createCodeFixer, answerAsExplorer, createAskExplorerTool, exploreInvocation, judgeFailure, SPEC_CONFLICT_RAISES, ENVIRONMENT_RAISES, environmentCheckPrompt, createTestReviewer, testReviewRequest, reviewFeedbackPrompt, testsFixPrompt, sortedRefs, } from "./conformance-agents.js";
 import { resolveRequiresChain } from "./requires.js";
@@ -192,8 +192,7 @@ export async function renderConformanceTests(options) {
     const reviewOn = configForSpec(options.plainFile).review === true;
     const reviewHistory = [];
     let specConflict;
-    let environment;
-    /** How many times in a row the run's environment was judged what is wrong. */
+    /** How many times in a row the run's environment, or the testing script, was judged what is wrong: the person's to fix. */
     let environmentRaises = 0;
     /** How many fixes in a row - the code's or the tests' - changed no file: an agent that will not, or cannot, act on the verdict. */
     let idleFixes = 0;
@@ -548,20 +547,25 @@ export async function renderConformanceTests(options) {
                         abandonWork(start, moduleName, "the conformance testing script needs more time than a test run may take");
                     throw timeLimitError(recheck, { moduleName, script: scripts.conformance, kind: "conformance", reason: verdict.reason });
                 }
-                // The environment - what the run is given - is the person's to fix: once judged so twice in a row, the run stops.
-                if (verdict.culprit === "environment") {
+                // The environment - what the run is given - or the testing script itself is the person's to fix: once judged so
+                // twice in a row, the pulse stops - rolled back, no retry - and the person is told what to fix.
+                if (verdict.culprit === "environment" || verdict.culprit === "script") {
+                    const culprit = verdict.culprit;
+                    const what = culprit === "script" ? "the conformance testing script itself" : "the run's environment";
                     environmentRaises += 1;
-                    reportActivity(`  the environment (judged ${environmentRaises} of ${ENVIRONMENT_RAISES} in a row): ${reason}`);
+                    reportActivity(`  ${what} (judged ${environmentRaises} of ${ENVIRONMENT_RAISES} in a row): ${reason}`);
                     if (environmentRaises >= ENVIRONMENT_RAISES) {
-                        stage("the run's environment is what is wrong, and only the person can fix it - stopping");
-                        environment = { reason: verdict.reason, times: environmentRaises };
-                        recordNote(conformanceDir, "pitfalls", `the conformance run's environment is wrong, for the person to fix: ${verdict.reason.replace(/\s+/g, " ").slice(0, 300)}`, `${label} conformance`);
-                        break;
+                        stage(`${what} is what is wrong, and only the person can fix it - stopping`);
+                        if (start !== undefined)
+                            abandonWork(start, moduleName, `${what} is what is wrong`);
+                        throw culprit === "script"
+                            ? scriptFaultError("script", { moduleName, script: scripts.conformance, kind: "conformance", reason: `judged so ${environmentRaises} times in a row: ${verdict.reason}` })
+                            : runEnvironmentError({ moduleName, script: scripts.conformance, reason: verdict.reason, times: environmentRaises });
                     }
-                    stage(`the run's environment is judged wrong (${environmentRaises} of ${ENVIRONMENT_RAISES}) - the conformance agent checks the tests do not cause it`);
-                    const fixed = await changing(() => askConformance(environmentCheckPrompt({ run: recheck, reason: verdict.reason }), options.onDelta));
+                    stage(`${what} is judged wrong (${environmentRaises} of ${ENVIRONMENT_RAISES}) - the conformance agent checks the tests do not cause it`);
+                    const fixed = await changing(() => askConformance(environmentCheckPrompt({ run: recheck, reason: verdict.reason, culprit }), options.onDelta));
                     response = fixed.result;
-                    recordAttempt(rounds, recheck, `the environment: ${verdict.reason}`, { who: "conformance agent", files: fixed.files });
+                    recordAttempt(rounds, recheck, `${what}: ${verdict.reason}`, { who: "conformance agent", files: fixed.files });
                     continue;
                 }
                 environmentRaises = 0;
@@ -824,7 +828,6 @@ export async function renderConformanceTests(options) {
             testRemovals,
             ...(specConflict !== undefined ? { specConflict } : {}),
             ...(stuck !== undefined ? { stuck } : {}),
-            ...(environment !== undefined ? { environment } : {}),
             ...(escalation !== undefined ? { escalation } : {}),
             ...(unlabelled !== undefined ? { unlabelled } : {}),
             ...(reviewWaived !== undefined ? { reviewWaived } : {}),

package/dist/regenerate/debugger.d.ts

@@ -24,6 +24,11 @@ export interface Diagnosis {
      * test run may take - which no agent can give it. Taken only of a run the limit stopped.
      */
     tooSlow?: boolean;
+    /**
+     * Not the code's: the testing script itself is wrong, or this machine lacks what it runs - it fails whatever the code
+     * and its tests are, and the coding agent may change neither. The pulse stops on it.
+     */
+    atFault?: "script" | "machine";
 }
 /** The debugger's account, as the coding agent is given it. */
 export declare function diagnosisText(diagnosis: Diagnosis): string;