@turri-dev/cli 0.1.3-next.6fab174 → 0.1.3-next.a5d3797

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

@@ -9,7 +9,7 @@ import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease,
 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,7 +31,7 @@ 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 } from "./regenerate/panel-dock.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";
@@ -186,7 +186,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;
         },
@@ -1531,7 +1532,10 @@ function registerJobTools(pi, jobs, cwd) {
                         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();
                     };
@@ -1624,6 +1628,17 @@ 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)
@@ -1655,8 +1670,13 @@ function registerJobTools(pi, jobs, cwd) {
             }, WATCH_REDRAW_MS);
             timer.unref?.();
             component = {
-                // Beside the chat, a rule down its left edge between them.
-                render: (width) => (panelBeside() > 0 ? view.render(width - 2).map((line) => `${theme.fg("borderMuted", "│")} ${line}`) : 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))
@@ -1797,6 +1817,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) {

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/regenerate/conformance-agents.js

@@ -659,15 +659,28 @@ function words(text) {
  * in the specification - or when it hides why the software failed. A test asserting what the
  * specification leaves open is the test's mistake, however plausible the assertion.
  */
-export function unfoundedCodeVerdict(verdict, specText) {
+export function unfoundedCodeVerdict(verdict, specText, scriptText) {
     if (verdict.causeHidden === true)
         return undefined;
+    // What the conformance testing script needs of the build - a file, an entry point, a module - binds the code as the
+    // specification does: neither agent can change the script. Its own words, as they are in it.
+    const needs = verdict.scriptNeeds?.trim() ?? "";
+    if (needs !== "" && scriptText !== undefined) {
+        const flat = (text) => text.replace(/\s+/g, " ");
+        if (flat(needs).length >= 4 && flat(scriptText).includes(flat(needs)))
+            return undefined;
+        if (verdict.specSays === undefined) {
+            return (`Your verdict blames the code for what the conformance testing script needs, but "${needs}" is not in the script. ` +
+                "Call submit_verdict again: copy into script_needs the script's own words for what it needs of the build, exactly as they are in it.");
+        }
+    }
     const quote = verdict.specSays?.trim() ?? "";
     if (quote === "") {
         return ("Your verdict blames the code, but quotes no words of the specification it does not meet. Call submit_verdict " +
             "again: for code, put the specification's own words the code does not meet in spec_says, copied exactly from " +
-            "<specification>; or set cause_hidden when the output does not show why the software failed. If the specification " +
-            "does not say what the failing test asserts, the test is what is wrong: culprit tests.");
+            "<specification>; or, when the run fails on something the conformance testing script needs the build to have, " +
+            "its own words in script_needs; or set cause_hidden when the output does not show why the software failed. If " +
+            "the specification does not say what the failing test asserts, the test is what is wrong: culprit tests.");
     }
     const quoted = words(quote);
     if (quoted.trim().split(" ").length < 4 || !words(specText).includes(quoted)) {
@@ -677,6 +690,31 @@ export function unfoundedCodeVerdict(verdict, specText) {
     }
     return undefined;
 }
+/**
+ * Why a verdict's evidence cannot be taken as it is, or nothing when it can. Asked to weigh an escalation, the judge has
+ * to rest its verdict on what it found itself: each piece of evidence from a file it opened, the testing script or the
+ * failing run - and at least one not the run alone, which every judge before it read too. What the explorer's account
+ * says is not evidence: it was written before the run, and may be wrong.
+ */
+export function unfoundedEvidence(evidence, opened) {
+    const given = (evidence ?? []).filter((item) => item.source.trim() !== "" && item.shows.trim() !== "");
+    if (given.length === 0) {
+        return ("Your verdict gives no evidence. Call submit_verdict again with `evidence`: what you found yourself - in a file you " +
+            "opened, the testing script, or the failing run - each with where. What <how to invoke it> says is not evidence: it " +
+            "may be wrong, so check it against the testing script and the files.");
+    }
+    const inPrompt = (source) => /^(the )?(conformance )?testing script$|^(the )?failing run$/i.test(source.trim());
+    const unread = given.filter((item) => !inPrompt(item.source) && !opened(item.source.trim()));
+    if (unread.length > 0) {
+        return (`Your evidence cites ${unread.map((item) => item.source.trim()).join(", ")}, which you did not open. Open each file you cite ` +
+            "and call submit_verdict again - evidence is what you found yourself, never what <how to invoke it> says.");
+    }
+    if (given.every((item) => /failing run$/i.test(item.source.trim()))) {
+        return ("Your evidence is only the failing run, which the judges before you read too. Check what it points at - the testing " +
+            "script, the code, the tests - and call submit_verdict again with what you found there.");
+    }
+    return undefined;
+}
 export async function judgeFailure(options) {
     let verdict;
     const submit = defineTool({
@@ -692,6 +730,13 @@ export async function judgeFailure(options) {
                 description: "For code: the specification's own words the code does not meet, copied exactly from <specification> - the sentence, or the part of it that says what the test checks",
             })),
             cause_hidden: Type.Optional(Type.Boolean({ description: "For code: true when it is wrong because the output does not show why the software failed - it hides the cause" })),
+            script_needs: Type.Optional(Type.String({
+                description: "For code: the conformance testing script's own words for what it needs the build to have - the file, entry point or module the run failed on - copied exactly from the script",
+            })),
+            evidence: Type.Optional(Type.Array(Type.Object({
+                source: Type.String({ description: "Where: the path of a file you opened, `testing script`, or `failing run`" }),
+                shows: Type.String({ description: "What it shows, e.g. `the script runs node dist/cli.js` or `tsconfig.json emits src/cli.ts as dist/src/cli.js`" }),
+            }), { description: "What you found yourself, each with where - never what <how to invoke it> claims unchecked" })),
             functionalities: Type.Optional(Type.Array(Type.Object({
                 module: Type.String({ description: "The module the functionality is in" }),
                 id: Type.String({ description: "Its id in that module" }),
@@ -704,6 +749,8 @@ export async function judgeFailure(options) {
                 reason: given.reason,
                 ...(given.spec_says?.trim() ? { specSays: given.spec_says.trim() } : {}),
                 ...(given.cause_hidden === true ? { causeHidden: true } : {}),
+                ...(given.script_needs?.trim() ? { scriptNeeds: given.script_needs.trim() } : {}),
+                ...(given.evidence !== undefined && given.evidence.length > 0 ? { evidence: given.evidence } : {}),
                 ...(given.functionalities ? { functionalities: conflictRefs(given.functionalities) } : {}),
             };
             return { content: [{ type: "text", text: "Recorded." }], details: {}, terminate: true };
@@ -712,10 +759,27 @@ export async function judgeFailure(options) {
     // It reads both, and changes neither: the file tools and the web - to look up what a service it calls answers -
     // and no shell. It judges from the code, the tests, the spec and the failing run's output, which it is given.
     const fence = confinedTools({ workdir: options.conformanceDir, read: [options.buildDir, options.conformanceDir], write: [], noBash: true });
+    // What it opens - read, listed, searched - is what its evidence can cite.
+    const openedPaths = new Set();
+    const tools = fence.tools.map((tool) => ({
+        ...tool,
+        execute: (async (...args) => {
+            const path = args[1]?.path;
+            if (typeof path === "string" && path !== "")
+                openedPaths.add(resolve(options.conformanceDir, path));
+            return tool.execute(...args);
+        }),
+    }));
+    const opened = (cited) => {
+        // A file it opened, or one in a folder it listed or searched; cited as it was opened, or relative to the code or the tests.
+        const candidates = [resolve(options.conformanceDir, cited), resolve(options.buildDir, cited)];
+        return candidates.some((path) => [...openedPaths].some((seen) => path === seen || path.startsWith(`${seen}/`)));
+    };
+    const scriptText = options.testingScripts?.map((script) => script.content).join("\n");
     const before = { code: digestFiles(options.buildDir), tests: digestFiles(options.conformanceDir) };
     const session = await createExecutor({
         cwd: options.conformanceDir,
-        customTools: [submit, ...createWebTools(), ...fence.tools],
+        customTools: [submit, ...createWebTools(), ...tools],
         tools: [...fence.names, ...WEB_TOOLS, "submit_verdict"],
         model: options.model,
         label: `${options.label} judge`, role: "judge",
@@ -730,8 +794,15 @@ export async function judgeFailure(options) {
                 await ask(session, "You have not called submit_verdict. Call it now: code, tests, spec or environment, and why.", options.onDelta);
                 continue;
             }
+            // Asked to weigh an escalation, a verdict of code or tests rests on what it found itself.
+            const unproven = options.escalation !== undefined && (verdict.culprit === "code" || verdict.culprit === "tests") ? unfoundedEvidence(verdict.evidence, opened) : undefined;
+            if (unproven !== undefined) {
+                verdict = undefined;
+                await ask(session, unproven, options.onDelta);
+                continue;
+            }
             if (verdict.culprit === "code") {
-                const unfounded = unfoundedCodeVerdict(verdict, options.spec.text);
+                const unfounded = unfoundedCodeVerdict(verdict, options.spec.text, scriptText);
                 if (unfounded === undefined)
                     break;
                 verdict = undefined;
@@ -759,18 +830,26 @@ export async function judgeFailure(options) {
     }
     if (verdict?.culprit === "spec" && specConflictProblem(verdict.functionalities, options.scope) !== undefined)
         verdict = undefined;
-    if (verdict?.culprit === "code" && unfoundedCodeVerdict(verdict, options.spec.text) !== undefined) {
+    // An escalation weighed without evidence escalates nothing: the tests stay the conformance agent's, as before it.
+    if (options.escalation !== undefined && verdict?.culprit === "code" && unfoundedEvidence(verdict.evidence, opened) !== undefined) {
+        return { culprit: "tests", reason: `${verdict.reason}\n\nBut the judge gave no evidence it found itself that the code is what is wrong, so the tests are looked at again.` };
+    }
+    if (verdict?.culprit === "code" && unfoundedCodeVerdict(verdict, options.spec.text, scriptText) !== undefined) {
         // Blaming the code takes the specification's own words; without them, the test asserts what the spec does not say.
         return { culprit: "tests", reason: `${verdict.reason}\n\nBut no words of the specification say so: a test that asserts what the specification does not say is what is wrong. Check each failing assertion against the specification, and assert only what it says.` };
     }
     if (verdict?.culprit === "code" && verdict.specSays !== undefined) {
         verdict = { ...verdict, reason: `${verdict.reason}\n\nThe specification says: "${verdict.specSays}"` };
     }
+    if (verdict?.culprit === "code" && verdict.scriptNeeds !== undefined) {
+        verdict = { ...verdict, reason: `${verdict.reason}\n\nThe conformance testing script needs: "${verdict.scriptNeeds}"` };
+    }
     // No verdict is no evidence the code is wrong: the tests are the newer work, and looked at first.
     return verdict ?? { culprit: "tests", reason: "The judge gave no verdict that could be used; check the failing tests against the specification first." };
 }
 export function judgePrompt(options) {
     const tested = options.scope.tested;
+    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.`,
@@ -780,7 +859,9 @@ export function judgePrompt(options) {
         "The specification is the judge, never either of them:",
         "- tests: a test asserts something the specification does not say, misreads it, or reaches the software the",
         "  wrong way - a wrong command, route or setup (see <how to invoke it>).",
-        "- code: the code does not do what the specification says, and the test checks exactly that.",
+        "- code: the code does not do what the specification says, and the test checks exactly that. Or the run fails",
+        "  on something the conformance testing script needs the code to provide - a build output, an entry point, a",
+        "  module - and the code does not provide it: quote the script's own words for it in script_needs.",
         "  Only what the specification says counts: anything it leaves open - a name, coordinates, a version, a path,",
         "  a package, a port, a file layout - is what the code already has. The tests follow it, and it is never",
         "  code - changing the code to fit a test's guess moves what every other test points at.",
@@ -810,6 +891,19 @@ export function judgePrompt(options) {
         "verdict of code without them is not taken. What the specification leaves open is never the code's fault: a test",
         "that asserts it - a status code, a message, a format the specification does not name - is what is wrong.",
         "",
+        ...(scripts.length > 0
+            ? [
+                "The conformance testing script below is how every run is made, and neither agent can change it: it is never",
+                "what is wrong. What it does with the tests, the tests have to fit; what it needs of the code - a file it runs or",
+                "checks for, a command it builds with - the code has to provide. A verdict that the script is wrong is neither",
+                "code nor tests: say which of the two has to change to get past it.",
+                "",
+            ]
+            : []),
+        "<how to invoke it> is the explorer's account, written before the run, and it can be wrong - a folder, a path, a",
+        "command. Never rest a verdict on it: check each claim you use against the testing script and the files, and give",
+        "in `evidence` what you found yourself, each with where.",
+        "",
         `You have ${JUDGE_CALLS} tool calls to decide in: read what the failure points at, not the whole codebase.`,
         "",
         "When the code and the tests could both be what is wrong, choose tests. When both are wrong, say which to fix",
@@ -832,11 +926,35 @@ export function judgePrompt(options) {
         "",
         `<how to invoke it>\n${options.invocation.trim()}\n</how to invoke it>`,
         "",
+        ...scripts.flatMap((script) => [`<conformance testing script path="${script.path}" run-as="${script.runs}">`, script.content.trimEnd(), "</conformance testing script>", ""]),
         `<failing run exit="${options.run.exitCode}" command="${options.run.command}">`,
         options.run.output.trimEnd(),
         "</failing run>",
+        ...(options.escalation !== undefined ? ["", ...escalationBlock(options.escalation)] : []),
     ].join("\n");
 }
+/** For the judge: the tests were fixed for this failure, and it did not go away - is it the code's? */
+function escalationBlock(escalation) {
+    const changed = escalation.changed.length === 0 ? "changed no file" : `changed ${escalation.changed.slice(0, 8).join(", ")}${escalation.changed.length > 8 ? ` and ${escalation.changed.length - 8} more` : ""}`;
+    return [
+        "<escalation>",
+        "This failure was judged the tests' before, and the conformance agent - who can change only the tests - was sent to",
+        `fix it. It ${changed}, and the run fails the same way. What it was told:`,
+        "",
+        escalation.reason.trim(),
+        "",
+        "Decide again, now whether the failure belongs to the code rather than the tests. It is the code's when the run",
+        "fails on something the code is meant to produce - a build output, an entry point, a module the testing script needs",
+        "- or when the tests ran and what the software does is not what the specification says. It stays the tests' when a",
+        "test is still wrong and the code is right: say exactly what in the tests, so the next fix is not the last one again.",
+        "",
+        "Gather the evidence yourself: open the files the failure points at - the code's build configuration and what it",
+        "emits, the tests - and read the testing script. Give it in `evidence`: a verdict of code or tests without evidence",
+        "you found is not taken. The coding agent is handed your reason and evidence: say what the code has to provide, and",
+        "where it now falls short (e.g. `the script runs dist/cli.js; the build emits dist/src/cli.js`).",
+        "</escalation>",
+    ];
+}
 /**
  * The coding agent a conformance run sends the code to, when the judge says the code is wrong: it
  * works in the code folder, may read the tests but never changes them, and keeps the unit
@@ -917,6 +1035,43 @@ export function codeFixPrompt(options) {
         "Fix the code, run the conformance tests and the unit tests, and finish.",
     ].join("\n");
 }
+/** How much of the conformance tests an escalation hands the coding agent, whole: the rest it reads itself. */
+const ESCALATED_TESTS_CHARS = 24_000;
+/**
+ * An escalated failure for the code fixer: the tests were fixed for it and it did not go away, and the judge found it
+ * the code's. It is handed the conformance testing script's error, the tests as they stand and the judge's evidence.
+ */
+export function escalatedFixPrompt(options) {
+    let room = ESCALATED_TESTS_CHARS;
+    const shown = options.tests.flatMap((test) => {
+        if (room <= 0)
+            return [`<conformance test path="${test.path}" shown="no - read it yourself" />`];
+        const content = test.content.length > room ? `${test.content.slice(0, room)}\n... (cut short - read the rest yourself)` : test.content;
+        room -= content.length;
+        return [`<conformance test path="${test.path}">`, content.trimEnd(), "</conformance test>"];
+    });
+    return [
+        `The conformance tests failed (exit ${options.run.exitCode}). The conformance agent was sent to fix the tests for it, and`,
+        "the run failed the same way. A judge then looked again, gathered the evidence below itself, and found that the",
+        "failure belongs to the code:",
+        "",
+        `<why the code>\n${options.reason.trim()}\n</why the code>`,
+        "",
+        "<evidence>",
+        ...options.evidence.map((item) => `- ${item.source.trim()}: ${item.shows.trim()}`),
+        "</evidence>",
+        "",
+        `<failing run command="${options.run.command}">`,
+        options.run.output.trimEnd(),
+        "</failing run>",
+        "",
+        "The conformance tests as they stand - not yours to change:",
+        ...shown,
+        "",
+        "Fix the code, run the conformance tests and the unit tests, and finish. This is the last attempt at this failure:",
+        "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. */
 export function environmentCheckPrompt(options) {
     return [

package/dist/regenerate/conformance.js

@@ -16,7 +16,7 @@ import { createMyDiffTool } from "./self-check.js";
 import { createServiceTools } from "./services.js";
 import { missingToolchainError, toolchainError } from "./environment-error.js";
 import { workspaceBlock } from "./workspace.js";
-import { codeFixPrompt, conflictKey, createCodeFixer, answerAsExplorer, createAskExplorerTool, exploreInvocation, judgeFailure, SPEC_CONFLICT_RAISES, ENVIRONMENT_RAISES, environmentCheckPrompt, createTestReviewer, testReviewRequest, reviewFeedbackPrompt, testsFixPrompt, sortedRefs, } from "./conformance-agents.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";
 import { notesToRead, recordNote } from "./notes.js";
 import { reportSpecConflict } from "./activity.js";
@@ -194,6 +194,11 @@ export async function renderConformanceTests(options) {
     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;
+    /** The last fix was the tests', for a failure judged theirs: should the run fail the same way again, the judge weighs escalating it. */
+    let testsFix;
+    /** A failure escalated to the code: should the run still fail the same way after the code's fix, the run stops. */
+    let escalated;
+    let escalation;
     /**
      * One attempt at the failing run, written into the notes' pitfalls - what the next judge reads
      * first - as cause and effect: what failed, how it was judged, and what was changed; the next
@@ -414,6 +419,15 @@ export async function renderConformanceTests(options) {
                     abandonWork(start, moduleName, "the conformance testing script could not run");
                 throw lacking;
             }
+            // A failure escalated to the code, still the same after the code's fix: neither agent could fix it, and the run stops
+            // with why the judge found it the code's. Anything else it fails on is a new failure, judged as any other.
+            if (escalated !== undefined && recheck.exitCode !== 0 && failureSignature(recheck) === escalated.signature) {
+                escalation = { reason: escalated.reason, evidence: escalated.evidence, error: failureLine(recheck), failure: truncateOutput(recheck.output, undefined).slice(-4000) };
+                stage("the failure escalated to the code is still there after the coding agent's fix - stopping");
+                recordNote(conformanceDir, "pitfalls", `stopped after ${rounds} attempts: failed with ${failureLine(recheck)}, escalated to the code - ${escalated.reason.replace(/\s+/g, " ").slice(0, 240)} - and the code's fix did not change it`, `${label} conformance`);
+                break;
+            }
+            escalated = undefined;
             if (recheck.exitCode !== 0) {
                 // Nothing changing: the same failure, taken the same way, round after round. Once, the explorer
                 // is asked what the tests lack - most often how they reach the software; after that, it stops.
@@ -504,6 +518,12 @@ export async function renderConformanceTests(options) {
                     recordNote(conformanceDir, "pitfalls", `stuck after ${rounds} attempts: failed with ${failureLine(recheck)}, and ${IDLE_FIXES} fixes in a row changed nothing`, `${label} conformance`);
                     return true;
                 };
+                // The tests were fixed for this very failure, and it is still here: the judge weighs whether it is the code's.
+                const signature = failureSignature(recheck);
+                const escalating = testsFix !== undefined && testsFix.signature === signature ? { reason: testsFix.reason, changed: testsFix.files } : undefined;
+                testsFix = undefined;
+                if (escalating !== undefined)
+                    stage("the tests' fix did not make the failure go away - the judge weighs whether it is the code's");
                 const verdict = await judgeFailure({
                     buildDir,
                     conformanceDir,
@@ -513,6 +533,9 @@ export async function renderConformanceTests(options) {
                     scope,
                     // The tests' notes - every attempt so far - and the code's: it weighs the one against the other.
                     notes: [notesToRead(conformanceDir), notesToRead(buildDir)].filter((part) => part !== "").join("\n\n"),
+                    // The script itself, so the judge checks the explorer's account against it rather than repeating it.
+                    testingScripts,
+                    ...(escalating !== undefined ? { escalation: escalating } : {}),
                     label,
                     model: judgeModel,
                     onDelta: options.onDelta,
@@ -585,15 +608,34 @@ export async function renderConformanceTests(options) {
                     recordAttempt(rounds, recheck, `a spec conflict between functionalities ${key}: ${verdict.reason}`, { who: "conformance agent", files: fixed.files });
                 }
                 else if (verdict.culprit === "code") {
-                    reportActivity(`  the code: ${reason}`);
-                    stage("the code is wrong - the coding agent fixes it");
-                    // One fixer for the run, starting each fix from what the ones before it tried: its work is compacted as
-                    // it gets longer, so a session carried through the run does not re-read every earlier fix and suite output
-                    // whole.
-                    const fixed = await changing(() => askFixer(codeFixPrompt({ run: recheck, reason: verdict.reason })));
-                    recordAttempt(rounds, recheck, `the code wrong: ${verdict.reason}`, { who: "coding agent", files: fixed.files });
-                    if (idle(fixed.files))
-                        break;
+                    if (escalating !== undefined) {
+                        // Escalated: the coding agent is handed the script's error, the tests as they stand and the judge's evidence.
+                        // Its fix is the last attempt at this failure - should the run fail the same way after it, the run stops.
+                        const evidence = verdict.evidence ?? [];
+                        reportActivity(`  escalated to the code: ${reason}`);
+                        stage("the judge finds the failure the code's - escalated to the coding agent");
+                        const tests = listFiles(conformanceDir).map((path) => ({ path, content: readFileSync(join(conformanceDir, path), "utf8") }));
+                        const fixed = await changing(() => askFixer(escalatedFixPrompt({ run: recheck, reason: verdict.reason, evidence, tests })));
+                        recordAttempt(rounds, recheck, `escalated to the code: ${verdict.reason}`, { who: "coding agent", files: fixed.files });
+                        if (fixed.files.length === 0) {
+                            escalation = { reason: verdict.reason, evidence, error: failureLine(recheck), failure: truncateOutput(recheck.output, undefined).slice(-4000), changedNothing: true };
+                            stage("the coding agent changed nothing for the failure escalated to it - stopping");
+                            break;
+                        }
+                        idleFixes = 0;
+                        escalated = { signature, reason: verdict.reason, evidence };
+                    }
+                    else {
+                        reportActivity(`  the code: ${reason}`);
+                        stage("the code is wrong - the coding agent fixes it");
+                        // One fixer for the run, starting each fix from what the ones before it tried: its work is compacted as
+                        // it gets longer, so a session carried through the run does not re-read every earlier fix and suite output
+                        // whole.
+                        const fixed = await changing(() => askFixer(codeFixPrompt({ run: recheck, reason: verdict.reason })));
+                        recordAttempt(rounds, recheck, `the code wrong: ${verdict.reason}`, { who: "coding agent", files: fixed.files });
+                        if (idle(fixed.files))
+                            break;
+                    }
                     // The fix has to build and pass its own unit tests before the suite runs again: a build
                     // error is the coding agent's to fix, not a judge's to work out from the suite's output.
                     for (let again = 0; again < FIX_UNIT_CHECKS; again += 1) {
@@ -613,7 +655,11 @@ export async function renderConformanceTests(options) {
                     const fixed = await changing(() => askConformance(testsFixPrompt({ run: recheck, reason: verdict.reason }), options.onDelta));
                     response = fixed.result;
                     recordAttempt(rounds, recheck, `the tests wrong: ${verdict.reason}`, { who: "conformance agent", files: fixed.files });
-                    if (idle(fixed.files))
+                    testsFix = { signature, reason: verdict.reason, files: fixed.files };
+                    // A fix that changed nothing does not stop the run before the judge has weighed escalating the failure.
+                    if (escalating === undefined)
+                        idleFixes = fixed.files.length === 0 ? idleFixes + 1 : 0;
+                    else if (idle(fixed.files))
                         break;
                 }
                 continue;
@@ -772,6 +818,7 @@ export async function renderConformanceTests(options) {
             ...(specConflict !== undefined ? { specConflict } : {}),
             ...(stuck !== undefined ? { stuck } : {}),
             ...(environment !== undefined ? { environment } : {}),
+            ...(escalation !== undefined ? { escalation } : {}),
             ...(unlabelled !== undefined ? { unlabelled } : {}),
             ...(reviewWaived !== undefined ? { reviewWaived } : {}),
             ...(verified && green !== undefined ? { green } : {}),

package/dist/regenerate/panel-dock.js

@@ -9,9 +9,9 @@ import { HStack } from "@earendil-works/pi-tui";
  */
 /** Narrower than this, the chat and the panel have no room side by side: the panel takes the whole screen. */
 const SHARED_FROM = 100;
-/** The columns the panel takes beside the chat - 0 when the terminal is too narrow to share. */
+/** The columns the panel takes beside the chat: half the screen, the rule between them in the middle - 0 when the terminal is too narrow to share. */
 export function dockedWidth(columns) {
-    return columns < SHARED_FROM ? 0 : Math.max(48, Math.floor(columns * 0.45));
+    return columns < SHARED_FROM ? 0 : Math.floor(columns / 2);
 }
 /**
  * The chat narrowed by `panelWidth()` columns, read at each frame - 0 gives it the whole width. Returns what gives it the
@@ -55,3 +55,32 @@ export function clickToFocus(tui, chatWidth, side) {
         screen.handleMouseEvent = handle;
     };
 }
+/**
+ * A line drawn faint - the side that does not have the keys, in the shade. Faint (SGR 2) holds through a line's colours;
+ * only a reset - SGR 0, or 22 - ends it, so it is set again after each one. A line holding an image is left as it is.
+ */
+export function shade(line) {
+    // Kitty's image escape, or iTerm2's.
+    if (line.includes("\x1b_G") || line.includes("\x1b]1337;File="))
+        return line;
+    const again = line.replace(/\x1b\[([\d;]*)m/g, (sgr, params) => (params.split(";").some((param) => param === "" || param === "0" || param === "22") ? `${sgr}${FAINT}` : sgr));
+    return `${FAINT}${again}${NOT_FAINT}`;
+}
+const FAINT = "\x1b[2m";
+const NOT_FAINT = "\x1b[22m";
+/**
+ * The chat in the shade while `shaded()`: each of its rows drawn faint as the screen lays the overlays over it - the
+ * docked panel the last of them, which covers its own columns. Returns what takes the shade off.
+ */
+export function shadeChat(tui, shaded) {
+    const screen = tui;
+    const composite = screen.compositeLineAt;
+    if (typeof composite !== "function")
+        return () => { };
+    screen.compositeLineAt = function (base, overlay, col, width, total) {
+        return composite.call(this, shaded() ? shade(base) : base, overlay, col, width, total);
+    };
+    return () => {
+        screen.compositeLineAt = composite;
+    };
+}

package/dist/regenerate/side-panel.js

@@ -16,7 +16,7 @@ export function createSidePanel(options) {
     const backKeys = () => {
         if (options.dock === undefined)
             return [`esc or ${options.key} back to the chat`];
-        return options.dock.docked() ? ["s full screen", "esc to the chat", `${options.key} close`] : ["s beside the chat", `esc or ${options.key} back to the chat`];
+        return options.dock.docked() ? ["s full screen", "esc or ⌥⌘← to the chat", `${options.key} close`] : ["s beside the chat", `esc or ${options.key} back to the chat`];
     };
     const waitingNote = () => 
     // A question asked while it showed waits in the chat, unanswered: the person is told it is there.

package/dist/regenerate/stop-report.js

@@ -89,6 +89,19 @@ export function describeStop(facts) {
                 `though they were sent back for it again and again. Still missing:\n${facts.conformance.unlabelled.map((line) => `    - ${line}`).join("\n")}`;
         todo = ["If the test reqs leave open where the tests go or how they are built, say so exactly - the folder, the files, the build."];
     }
+    else if (facts.at === "conformance" && facts.conformance?.escalation !== undefined) {
+        const { error, reason, evidence, changedNothing } = facts.conformance.escalation;
+        why =
+            `its conformance tests kept failing with ${error}. The conformance agent's fix of the tests did not make it go away, so ` +
+                `a judge looked again and found it the code's; the coding agent ${changedNothing === true ? "changed nothing for it" : "fixed the code, and the run still failed the same way"}. ` +
+                `Why the judge found it the code's:\n${reason.trim().split("\n").map((line) => `    ${line}`).join("\n")}` +
+                (evidence.length > 0 ? `\n  On the evidence:\n${evidence.map((item) => `    - ${item.source.trim()}: ${item.shows.trim().replace(/\s+/g, " ")}`).join("\n")}` : "");
+        todo = [
+            "If the code has to produce something the spec leaves open - a build output, an entry point, a module the conformance testing " +
+                "script runs or checks for - say exactly what in the implementation reqs: its path and how it is built.",
+            "If the conformance testing script expects something the spec does not ask for, change the script or the test reqs so the two agree.",
+        ];
+    }
     else if (facts.at === "conformance" && facts.conformance?.stuck !== undefined) {
         const { error, times, rounds, changedNothing } = facts.conformance.stuck;
         why =

package/dist/regenerate-cli.js

@@ -19,7 +19,7 @@ its conformance tests too when they are on.
   --start-over             start over, without asking, a codebase regenerated without a module it now requires -
                            with no terminal to ask and without it, the run stops there
   --from-scratch           delete the module's code and conformance tests (its lineage keeps them) and regenerate all of it
-  --harness-model <p/id>   config.turri.yaml's harness-model for this run: the planner, the conformance chooser, a diagnosis
+  --harness-model <p/id>   config.turri.yaml's harness-model for this run: the planner and the conformance chooser
   --coding-model <p/id>    its coding-model, --model too: the agents that build; p/id:level for how hard a model thinks
   --judge-model <p/id>     its judge-model: the judge and the test review
   --review <true|false>    its review: whether the code and its tests are reviewed once they pass

package/docs/config.md

@@ -122,7 +122,7 @@ models:                              # each agent role's model, thinking and tur
 | key | what it sets | left out |
 | --- | --- | --- |
 | `module` | the `.plain` file `turri regenerate` and the chat's `regenerate` build when none is named, from the project root | a file has to be named |
-| `harness-model` | the model `turri` starts on - the one you talk to - the one that diagnoses a job that failed for good, and, in the conversation, the planner that cuts the work into jobs (on whatever model the chat is on when it plans); under `turri regenerate`, the planner too | pi's configured model |
+| `harness-model` | the model `turri` starts on - the one you talk to - and, in the conversation, the planner that cuts the work into jobs (on whatever model the chat is on when it plans); under `turri regenerate`, the planner too | pi's configured model |
 | `coding-model` | every render: functionalities, spec diffs, conformance tests, repairs, planning spec diffs, the explorer | `harness-model` |
 | `judge-model` | the judge and the test review of a conformance run | `coding-model` |
 | `conformance-tests` | `all` (or `true`): conformance tests for every functional spec of every module with test reqs, written once each module's code is built, before anything is built on it. `chosen`: for the functional specs chosen - every one with acceptance tests, and those the chooser picks as each code pulse ends, from what that pulse regenerated. `module`: the same, but the chooser is asked once, when the whole module is regenerated, and plans the conformance pulses too. Under both, the choice is made inside the pulse, before anything is built on the module, and the pulse's report says what was chosen and why; those the person asks for with `conform` are written too; once chosen, a functional spec keeps them, and they are rewritten when it changes - see [who chooses, and when](regenerating.md#conformance-tests-in-the-work-loop). `false`: none written, and none of the existing ones run - until the conversation asks with `conform` | `false` |
@@ -158,7 +158,8 @@ wrong type, as if it were not there. `model:`, from before there were separate m
 | --- | --- |
 | `default` | every role not named below - but the conversation's side |
 | `chat` | `turri`'s model - the same as `harness-model`, which it wins over |
-| `chooser`, `planner`, `diagnosis` | the conversation's side: the conformance chooser of `turri regenerate`, the planner's agents, the diagnosis of a failed job. Unnamed, the chat's model |
+| `chooser`, `planner` | the conversation's side: the conformance chooser of `turri regenerate`, the planner's agents. Unnamed, the chat's model |
+| `diagnosis` | the diagnosis of a job that failed for good: why it did not land, and what to do. Unnamed, the coding model the job ran on, thinking medium |
 | `release` | `turri release`'s agent and release-after-pulse's: it follows steps - a script, a start command - so it runs on the coding model, thinking low |
 | `coding` | the coding agent, the code fixer of a conformance run and the repair agent - the same as `coding-model`, which it wins over. `--model` on the command line, or a model chosen in the conversation (`engine`), wins over both |
 | `conformance` | the conformance agent |

package/docs/headless.md

@@ -81,7 +81,7 @@ Useful options - `turri regenerate --help` lists all of them:
 
 | | |
 | --- | --- |
-| `--harness-model <provider/id>` | `harness-model`: the planner, the conformance chooser, the diagnosis of a failed pulse |
+| `--harness-model <provider/id>` | `harness-model`: the planner and the conformance chooser |
 | `--coding-model <provider/id>` | `coding-model` (`--model` too): the agents that build - with `:level` for how hard it thinks (`provider/id:high`); not given, the harness model's |
 | `--judge-model <provider/id>` | `judge-model`: the judge and the test review; not given, the coding model |
 | `--conformance-tests <all\|chosen\|module\|false>` | `conformance-tests`, with its values (`true` is `all`) |
@@ -151,7 +151,7 @@ changes meaning or goes; new fields may appear in the same version. Paths in `pu
   "conformance_tests": "all",                                                       // all | chosen | module | false
   "review": false,
   "models": {
-    "harness": { "model": "…", "thinking": "medium" },  // the planner, the chooser, the diagnosis
+    "harness": { "model": "…", "thinking": "medium" },  // the planner, the chooser
     "coding":  { "model": "…", "thinking": "low" },
     "judge":   { "model": "…", "thinking": "medium" },
     "observed": { "coding": ["provider/id:low"], "planner": ["provider/id:medium"] }  // what each role really ran on

package/docs/regenerating.md

@@ -906,10 +906,16 @@ agent is told that a failure of the software itself - it does not build or start
 spec says it must not - is not the tests' to work around. When it fails, a judge - an agent that reads
 the code and the tests, changes neither, and holds both to the spec - decides which is wrong. It has the
 file tools and the web (`web_search`, `web_fetch`), to look up what a service the code calls answers - no shell: it
-judges from the code, the tests, the spec and the failing run's output, and its file tools write nothing:
+judges from the code, the tests, the spec, the conformance testing script word for word and the failing run's output,
+and its file tools write nothing. The explorer's account of how the code is invoked is in its prompt too, marked as
+written before the run and possibly wrong: the judge checks what it uses of it against the script and the files, and
+gives in `evidence` what it found itself. The script is fixed - neither agent can change it - so it is never the
+culprit: what it does with the tests, the tests fit; what it needs of the build, the code provides.
 
 - **the code:** the coding agent - in the code's folder, reading the tests but never changing them - fixes it,
-  and keeps its unit tests passing;
+  and keeps its unit tests passing. The judge quotes the spec's own words the code does not meet, or the testing
+  script's for what it needs of the build (`script_needs`: a build output, an entry point, a module) - each checked
+  by the harness against the text it quotes;
 - **the tests:** the conformance agent corrects them to what the spec says;
 - **the spec:** two functional specs cannot both hold, whatever the code does;
 - **the environment:** neither the code nor the tests can fix it - only the person can, in what the run is given:
@@ -953,6 +959,20 @@ response, a UUID or a correlation id. Nothing changes either when the agent sent
 changes no file: two such fixes in a row, and the run stops. The conformance agent has the testing script in its prompt,
 and is told to fit the tests' own build to it.
 
+**Escalation.** A failure judged the tests' goes to the conformance agent first: it owns the tests. When the run then
+fails the same way - the fix changed nothing, or nothing that mattered - the judge is asked again, now whether the
+failure belongs to the code rather than the tests: the run failing on something the code is meant to produce (a build
+output, an entry point, a module the testing script needs), or the tests running and the behaviour itself being
+wrong. Its verdict, either way, has to rest on evidence it gathered: each piece from a file it opened (the harness
+keeps track of what it read, listed and searched), the testing script or the failing run - and not the run alone.
+A verdict without it is sent back; a verdict of code still without it is taken as the tests'. Judged the tests'
+again, the failure stays with the conformance agent, and a fix that changes nothing counts towards stopping as
+before. Judged the code's, it is escalated to the coding agent, handed the script's error, the conformance tests as
+they stand and the judge's reason and evidence (`the script runs dist/cli.js; the build emits dist/src/cli.js`). Its
+fix has to build and pass the unit tests, then the suite runs again. Should the run still fail the same way - or the
+fix change nothing - the run stops there, with the judge's reasoning and evidence in what the person is told. Each of
+these runs is one of the run's 20 attempts, so a failure neither agent can fix stops in three of them.
+
 Every attempt is written into the working notes' pitfalls by the harness as cause and effect - what
 the run failed with, how it was judged, and which files the agent sent to fix it changed; the next
 attempt's line says what came of it - and each judge reads them first, so it does not send a

package/docs/using.md

@@ -131,7 +131,7 @@ come waits for a free slot, and says so.
   keyboard protocol sends as a line feed, the same as `shift+enter`, and which a dialog takes for
   `enter`; both stay pi's new-line keys. `ctrl+h` is the byte old terminals sent for backspace; a
   terminal set to send `^H` for its Backspace key would open the panel on it) takes the whole screen - the panel or the chat, one at a time -
-  or, `s`, sits beside the chat: the chat on the left, the panel in the right 45% of the screen, and `s` again
+  or, `s`, sits beside the chat: the chat on the left, the panel in the right half of the screen, and `s` again
   over the whole screen. It opens as it was last left, for the conversation; a terminal under 100 columns has
   no room for both and shows the panel over the whole screen.
   It opens on **regen**: the spec itself, in full, with how much of it the code has been regenerated from drawn
@@ -218,7 +218,9 @@ come waits for a free slot, and says so.
   said and did is not shown - it is in each pulse's log (see [Agent logs](#agent-logs)).
 
   `ctrl+h` again, or `esc`, closes it and goes back to the chat. Beside the chat, a click decides which side has
-  the keys - the chat or the panel, the one clicked - and `esc` gives the chat the keys too, the panel staying and
+  the keys - the chat or the panel, the one clicked, or the one `⌥⌘←` / `⌥⌘→` points at (on a
+  terminal that passes ⌘ on, over the Kitty keyboard protocol - Ghostty, kitty, WezTerm, iTerm2; not Apple's Terminal);
+  the other is drawn faint - and `esc` gives the chat the keys too, the panel staying and
   following the pulses; `ctrl+h` gives the panel the keys again, and from the panel closes it. (pi's regular screen,
   `--tui-mode regular`, reads no mouse: there it is the keys alone.)
   While the panel has the keys, every key is the panel's,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.3-next.6fab174",
+  "version": "0.1.3-next.a5d3797",
   "license": "MIT",
   "type": "module",
   "repository": {