@turri-dev/cli 0.1.3-next.f74e98a → 0.1.4-next.172be6f

package/README.md

@@ -27,7 +27,7 @@ npm install -g @turri-dev/cli # puts `turri` on your PATH
 turri doctor              # checks the machine
 ```
 
-To work on turri itself, run it from a clone instead - see [installation](docs/installation.md#from-a-clone).
+To follow `main` as it moves, or work on turri itself, run it [from a clone](#from-a-clone) instead.
 
 `doctor` checks for Node 22.19+, bash, the OS sandbox and a model provider for pi; in a project, the toolchains its
 modules need, what its testing scripts run against this machine, and that each model `config.turri.yaml` names
@@ -73,6 +73,27 @@ Rather not install Node and the rest? **turri** also runs in Docker, from one im
 
 Choosing models: [models](#models); what to do next: [use](#use).
 
+### From a clone
+
+In place of the npm package - for the latest of `main`, or to change turri itself:
+
+```bash
+git clone git@github.com:turri-oss/turri.git && cd turri
+npm install
+npm link        # puts `turri` on your PATH, pointing at this clone
+turri doctor
+```
+
+The clone runs its TypeScript sources directly, so there is nothing to build. When new commits land:
+
+```bash
+git pull
+npm install     # picks up any dependency that changed
+```
+
+A **turri** already running keeps the code it started with - start it again to run what you pulled. More in
+[installation](docs/installation.md#from-a-clone).
+
 ## Why
 
 In the age of coding agents, writing code is getting easy. The hard and important part is

package/dist/ask.js

@@ -9,6 +9,9 @@ import { PANEL_KEY } from "./regenerate/job-panel.js";
 export const OTHER_OPTION = "Something else…";
 export const CHAT_OPTION = "Chat about this";
 export const DONE_OPTION = "Done — that's all of them";
+/** An option's box in a question of several, ticked and not. */
+export const TICKED = "☑";
+export const UNTICKED = "☐";
 export const DISMISSED = "The user dismissed the question without answering.";
 /** How an answer that is no answer starts: the person chose to talk about the question first. */
 export const CHAT_PREFIX = "The user has not answered this question yet: they chose to talk about it first.";
@@ -107,32 +110,48 @@ export async function runAsk(asked, io) {
             return choice;
         }
     }
-    // Pick several: keep offering what is left until they say they are done.
-    const chosen = [];
-    let remaining = [...options];
-    while (remaining.length > 0) {
-        const title = chosen.length === 0 ? request.question : `${request.question}  [so far: ${chosen.join(", ")}]`;
-        const choice = await io.select(title, [...remaining, ...extras, DONE_OPTION], context);
-        if (choice === undefined)
-            break;
-        if (choice === DONE_OPTION)
+    // Pick several: every option a box, ticked and unticked as it is chosen, until they say they are done. What they type
+    // is one more box, ticked - and can be unticked too. Something else, Chat about this and Done are no boxes.
+    const listed = [...options];
+    const ticked = new Set();
+    const picked = () => listed.filter((option) => ticked.has(option));
+    let at = 0;
+    for (;;) {
+        const rows = listed.map((option) => `${ticked.has(option) ? TICKED : UNTICKED} ${option}`);
+        const choice = await io.select(request.question, [...rows, ...extras, DONE_OPTION], context, at);
+        if (choice === undefined || choice === DONE_OPTION)
             break;
         if (choice === OTHER_OPTION) {
+            at = listed.length;
             const typed = await typeInstead();
-            if (!typedNothing(typed))
-                chosen.push(typed.trim());
+            if (typedNothing(typed))
+                continue;
+            const option = typed.trim();
+            if (!listed.includes(option))
+                listed.push(option);
+            ticked.add(option);
+            at = listed.indexOf(option);
             continue;
         }
         if (choice === CHAT_OPTION) {
+            at = listed.length + extras.indexOf(CHAT_OPTION);
             const said = await chatAbout();
             if (typedNothing(said))
                 continue;
-            return chatAnswer(said, chosen);
+            return chatAnswer(said, picked());
         }
-        chosen.push(choice);
-        remaining = remaining.filter((option) => option !== choice);
+        // A row, or - where the answer is typed, on the command line - an option by its text, or one more of their own.
+        const row = rows.indexOf(choice);
+        const option = row !== -1 ? listed[row] : choice.trim();
+        if (!listed.includes(option))
+            listed.push(option);
+        if (ticked.has(option))
+            ticked.delete(option);
+        else
+            ticked.add(option);
+        at = listed.indexOf(option);
     }
-    return chosen.length > 0 ? chosen.join(", ") : DISMISSED;
+    return ticked.size > 0 ? picked().join(", ") : DISMISSED;
 }
 /**
  * While a question is open, what catches ctrl+h on the terminal's input: pi gives an extension's shortcut only the keys

package/dist/cli-options.js

@@ -1,4 +1,4 @@
-import { conformanceOption, overrideConfig, reviewOption, splitModelSpec } from "./config.js";
+import { booleanOption, conformanceOption, overrideConfig, splitModelSpec } from "./config.js";
 /**
  * The command line of turri's commands: their words, and the options that stand for the config's own keys - kept apart
  * from the commands that use them, so a light one (doctor) reads them as a regenerate does without loading it.
@@ -51,19 +51,24 @@ export function optionValue(options, name) {
 }
 /**
  * The options that stand for the config's own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`
- * and, as asked, `--review` and `--conformance-tests` - read as if config.turri.yaml had them, in their place in the
+ * and, as asked, `--review`, `--mutation-testing` and `--conformance-tests` - read as if config.turri.yaml had them, in their place in the
  * order the config resolves them in (overrideConfig): a run, or doctor, with them is the same as one with them in the
  * file. Exits on a value it cannot read.
  */
 export function configKeyOptions(options, take = {}) {
+    const flag = (name) => {
+        const given = take.review === true ? optionValue(options, name) : undefined;
+        const value = given !== undefined ? booleanOption(given) : undefined;
+        if (given !== undefined && value === undefined)
+            failOption(`--${name} takes true or false, not ${given}`);
+        return value;
+    };
     const tests = take.conformance === true ? optionValue(options, "conformance-tests") : undefined;
     const setting = tests !== undefined ? conformanceOption(tests) : undefined;
     if (tests !== undefined && setting === undefined)
         failOption(`--conformance-tests takes all, chosen, module or false, not ${tests}`);
-    const reviewed = take.review === true ? optionValue(options, "review") : undefined;
-    const review = reviewed !== undefined ? reviewOption(reviewed) : undefined;
-    if (reviewed !== undefined && review === undefined)
-        failOption(`--review takes true or false, not ${reviewed}`);
+    const review = flag("review");
+    const mutationTesting = flag("mutation-testing");
     const model = (name, key) => {
         const spec = optionValue(options, name);
         return spec !== undefined ? { [key]: splitModelSpec(spec) } : {};
@@ -74,6 +79,7 @@ export function configKeyOptions(options, take = {}) {
         ...model("judge-model", "judgeModel"),
         ...(setting !== undefined ? { conformanceTests: setting } : {}),
         ...(review !== undefined ? { review } : {}),
+        ...(mutationTesting !== undefined ? { mutationTesting } : {}),
     });
 }
 function failOption(message) {

package/dist/config-edit.js

@@ -59,6 +59,7 @@ export function settings(rules = []) {
         { key: "conformance-tests", about: "which functional specs get conformance tests", kind: "choice", options: ["all", "chosen", "module", "false"], unset: "all, where a module has test reqs", effect: "next-plan" },
         { key: "conformance-budget", about: "under conformance-tests: chosen or module, how many may be chosen - a count or a share", kind: "budget", options: ["10%", "30%", "50%", "5", "10"], unset: "no limit", effect: "next-plan" },
         { key: "review", about: "whether the code and its tests are reviewed once they pass", kind: "boolean", unset: "true", effect: "next-pulse" },
+        { key: "mutation-testing", about: "whether the coding agent and the reviewer can put a bug in the code for one test run (can_it_fail)", kind: "boolean", unset: "true", effect: "next-pulse" },
         { key: "allow-to-stop-jobs", about: "whether turri stops a running pulse the spec has moved on from", kind: "boolean", unset: "true", effect: "now" },
         { key: "release-after-pulse", about: "whether every pulse that lands code releases it", kind: "boolean", unset: "false", effect: "next-landing" },
         { key: "unittests-script", about: "the unit testing script, by path from the project root", kind: "path", unset: "the one run_unittests*.sh found", effect: "next-test-run" },

package/dist/config.js

@@ -21,6 +21,7 @@ import { projectDirOf } from "./regenerate/paths.js";
  * conformance-tests: chosen                                 # all, chosen (those with acceptance tests, and those the chooser picks after each pulse), module (the chooser picks, and plans, once the module is regenerated) or false (default: false)
  * conformance-budget: 30%                                   # under chosen or module: how many functional specs a module may have chosen, beside those with acceptance tests - a count or a share (default: no limit)
  * review: false                                             # review the code and its tests once they pass (default: true)
+ * mutation-testing: false                                   # give the coding agent and the reviewer can_it_fail (default: true)
  * allow-to-stop-jobs: false                                 # stop a running job the spec moved on from (default: true)
  * release-after-pulse: true                                 # release what each pulse lands, as its last stage, before the next pulse (default: false)
  * rules-off: [integrations]                                 # ***plain rules to leave out of the prompts, by name (default: none)
@@ -331,6 +332,7 @@ export const CONFIG_KEYS = {
     conformanceTests: "conformance-tests",
     conformanceBudget: "conformance-budget",
     review: "review",
+    mutationTesting: "mutation-testing",
     allowToStopJobs: "allow-to-stop-jobs",
     releaseAfterPulse: "release-after-pulse",
     unittestsScript: "unittests-script",
@@ -416,8 +418,8 @@ export function overrideConfig(overrides) {
 export function conformanceOption(value) {
     return conformanceSetting(value);
 }
-/** `--review <value>`: the config's own, true or false. Undefined for anything else. */
-export function reviewOption(value) {
+/** `--review <value>`, `--mutation-testing <value>`: the config's own, true or false. Undefined for anything else. */
+export function booleanOption(value) {
     const word = value.trim().toLowerCase();
     return word === "true" ? true : word === "false" ? false : undefined;
 }
@@ -487,6 +489,7 @@ function readConfigFile(path) {
         conformanceTests: conformanceSetting(conformance),
         conformanceBudget: budgetSetting(raw[CONFIG_KEYS.conformanceBudget]),
         review: typeof raw[CONFIG_KEYS.review] === "boolean" ? raw[CONFIG_KEYS.review] : undefined,
+        mutationTesting: typeof raw[CONFIG_KEYS.mutationTesting] === "boolean" ? raw[CONFIG_KEYS.mutationTesting] : undefined,
         allowToStopJobs: typeof raw[CONFIG_KEYS.allowToStopJobs] === "boolean" ? raw[CONFIG_KEYS.allowToStopJobs] : undefined,
         releaseAfterPulse: typeof raw[CONFIG_KEYS.releaseAfterPulse] === "boolean" ? raw[CONFIG_KEYS.releaseAfterPulse] : undefined,
         unittestsScript: text(raw[CONFIG_KEYS.unittestsScript]),

package/dist/extension.js

@@ -16,7 +16,7 @@ import { readScript, scriptAgainstMachine, stackOnMachine, toolchainsBlock } fro
 import { sandboxAvailable, sandboxSummary } from "./regenerate/os-sandbox.js";
 import { findTestScripts } from "./regenerate/test-scripts.js";
 import { createAskUserTool } from "./tools.js";
-import { asksFromScratch, driftTool, fromWorkingDir, haltTool, loopReply, MODEL_PARAM, regenerateTool, stopJob, WAIT_PARAM, WORKING_DIR_PARAM } from "./loop-tools.js";
+import { asksFromScratch, asksWholeChain, driftTool, fromWorkingDir, haltTool, loopReply, MODEL_PARAM, regenerateTool, stopJob, WAIT_PARAM, WORKING_DIR_PARAM } from "./loop-tools.js";
 import { createWebTools } from "./regenerate/web.js";
 import { describeGates, interruptedRun, runSkill } from "./genome.js";
 import { skillStatus } from "./skill.js";
@@ -41,7 +41,7 @@ import { createJobsTreeState, selectJob } from "./regenerate/jobs-tree.js";
 import { describeDiagnosis, diagnoseFailure } from "./regenerate/diagnose.js";
 import { HISTORY_DIR, historyLog, historyShow } from "./regenerate/lineage.js";
 import { defaultBuildDir } from "./regenerate/paths.js";
-import { describeUsage } from "./regenerate/activity.js";
+import { describeTurnIncident, describeUsage, onModelEvent } from "./regenerate/activity.js";
 import { describeSpecConflict } from "./regenerate/stop-report.js";
 import { inheritProviders, inheritThinkingLevel } from "./pi.js";
 import { beginCapture, captureConsole, describeCaptured, dropNoise } from "./quiet.js";
@@ -90,17 +90,26 @@ aside) {
             // The question, with what the asker gives to read for it - a brief to confirm - above it; what it said of its work
             // before asking is kept in its record, never put in the dialog.
             // A dialog of turri's own: a long brief scrolls above the question, and the options always show (question-dialog.ts).
-            const dialog = (question, context, options) => ctx.ui.custom((tui, theme, _keybindings, done) => new QuestionDialog({
-                question,
-                ...(context !== undefined ? { context } : {}),
-                ...(options !== undefined ? { options } : {}),
-                rows: () => tui.terminal.rows,
-                style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
-                done,
-                requestRender: () => tui.requestRender(),
-            }));
+            const dialog = (question, context, options, selected) => ctx.ui.custom((tui, theme, _keybindings, done) => {
+                const shown = new QuestionDialog({
+                    question,
+                    ...(context !== undefined ? { context } : {}),
+                    ...(options !== undefined ? { options } : {}),
+                    ...(selected !== undefined ? { selected } : {}),
+                    rows: () => tui.terminal.rows,
+                    style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
+                    done: (answer) => {
+                        if (questionShown === shown)
+                            questionShown = undefined;
+                        done(answer);
+                    },
+                    requestRender: () => tui.requestRender(),
+                });
+                questionShown = shown;
+                return shown;
+            });
             const asking = (asked) => runAsk(asked, {
-                select: (title, options, context) => dialog(title, context, options),
+                select: (title, options, context, at) => dialog(title, context, options, at),
                 input: (title, context) => dialog(title, context),
             });
             const bare = { ...request, said: undefined };
@@ -117,6 +126,12 @@ aside) {
 }
 /** The side panel, as a question open in the chat reaches it: set once the extension has its panel. */
 let questionPeek;
+/**
+ * The question open in the chat now, if any. The side panel gives the keys back to it: pi would give them to what had the
+ * focus when the panel first opened, and a panel kept beside the chat outlives that question - the keys would go to a
+ * dialog already answered, and nothing would take them.
+ */
+let questionShown;
 /** A widget with nothing to draw: below the editor, it takes no line. */
 const PEEK_KEY_WIDGET = "turri-peek-key";
 /**
@@ -313,6 +328,19 @@ export default function (pi) {
     };
     pi.on("agent_end", endTurnCapture);
     pi.on("agent_settled", endTurnCapture);
+    // A pulse's provider failing and waited out, or a turn turri ended itself: said in the chat as it happens - the job
+    // panel's activity holds it too, but scrolls by.
+    let stopTurnIncidents;
+    pi.on("session_start", (_event, ctx) => {
+        stopTurnIncidents?.();
+        if (!ctx.hasUI)
+            return;
+        stopTurnIncidents = onModelEvent((event) => {
+            const line = describeTurnIncident(event);
+            if (line !== undefined)
+                ctx.ui.notify(event.job !== undefined ? `${event.job}: ${line}` : line, "warning");
+        });
+    });
     // What a turri that was killed left running - its commands' process groups - stopped as this one starts.
     const orphans = sweepOrphanedGroups();
     let orphansSaid = orphans === 0;
@@ -534,7 +562,7 @@ export default function (pi) {
                 loopTools: [
                     regenerateTool({ cwd, jobs, loop: () => workLoopFor(jobs, cwd, ctx), model: (_skill, plainFile, named, work) => jobModel(ctx, work ?? "spec_changes", named, plainFile), wait: () => false }),
                     driftTool({ cwd, jobs, loop: () => workLoopFor(jobs, cwd, ctx) }),
-                    haltTool({ jobs }),
+                    haltTool({ jobs, workLoop: () => workLoops.get(jobs)?.loop }),
                     conformTool({ cwd, loop: () => workLoopFor(jobs, cwd, ctx), model: (_skill, plainFile, named) => jobModel(ctx, "spec_changes", named, plainFile), wait: () => false }),
                 ],
                 // The escalation becomes a real dialog in the TUI. Without dialog-capable
@@ -596,7 +624,7 @@ function registerRegenerate(pi, cwd, jobs) {
     // by the planner: one functional spec at a time, a few together or the whole module in one, as it judges. What
     // follows the module is guidance for that plan, in the person's words.
     pi.registerCommand("regenerate", {
-        description: "Regenerate a module from its spec as it is now, in pulses the planner cuts - named functionalities though they did not change, or all of it from scratch: /regenerate [module | file.plain] [functionality ...] [from scratch] [how to cut the work]",
+        description: "Regenerate a module from its spec as it is now, in pulses the planner cuts - named functionalities though they did not change, or all of it from scratch, its whole chain too when asked: /regenerate [module | file.plain] [functionality ...] [from scratch [whole chain]] [how to cut the work]",
         handler: async (args, ctx) => {
             const command = `/regenerate ${args.trim()}`.trim();
             await echoCommand(pi, command);
@@ -638,13 +666,17 @@ function registerRegenerate(pi, cwd, jobs) {
             }
             // From scratch - started over, its code deleted - asked in the person's words: confirmed first, as it deletes.
             const scratch = asksFromScratch(guidance);
+            // The whole chain with it - "from scratch, the whole chain" - every module it requires built again from the bottom.
+            const chain = scratch && asksWholeChain(guidance);
             const module = basename(plainFile).replace(/\.plain$/, "");
             if (scratch && again.length > 0) {
                 say("Name functionalities or ask for it from scratch, not both: from scratch regenerates every one of them.", "warning");
                 return;
             }
             if (scratch && ctx.hasUI) {
-                const agreed = await ctx.ui.confirm(`Regenerate ${module} from scratch?`, `Its code and conformance tests are deleted - committed first, so /lineage ${module} keeps them - and the whole module is regenerated from its spec.`);
+                const agreed = await ctx.ui.confirm(chain ? `Regenerate ${module} and its whole chain from scratch?` : `Regenerate ${module} from scratch?`, chain
+                    ? `The code and conformance tests of ${module} and of every module it requires are deleted - committed first, so /lineage keeps them - and the whole chain is regenerated from its spec, from the bottom.`
+                    : `Its code and conformance tests are deleted - committed first, so /lineage ${module} keeps them - and the whole module is regenerated from its spec.`);
                 if (!agreed)
                     return;
             }
@@ -654,14 +686,14 @@ function registerRegenerate(pi, cwd, jobs) {
             // Said at once, and kept in the chat: what follows takes a while - the planner is an agent - and the person sees it
             // began, not a chat that stays empty until the first pulse starts. The plan is said under it once it is made.
             say(scratch
-                ? `Deleting ${module}'s code, then planning all of it again…`
+                ? `Deleting ${module}'s code${chain ? " and its whole chain's" : ""}, then planning all of it again…`
                 : again.length > 0
                     ? `Planning ${module}'s functionalit${again.length === 1 ? "y" : "ies"} ${again.join(", ")} again…`
                     : `Planning ${module}'s pulses…`, "info");
             await nextFrame();
             try {
                 const statuses = scratch
-                    ? await loop.fromScratch(plainFile, request)
+                    ? await loop.fromScratch(plainFile, { ...request, chain })
                     : again.length > 0
                         ? await loop.regenerateAgain(plainFile, again, request)
                         : await loop.bringUp(plainFile, request);
@@ -1405,25 +1437,37 @@ function registerJobTools(pi, jobs, cwd) {
     // The panel is compact and ctrl+o only lasts as long as the work does. This is the whole
     // list, finished jobs included, put in the transcript where it stays.
     pi.registerCommand("halt", {
-        description: "Halt a queued or running pulse, or what activate started: /halt [pulse id | activated <name>]",
+        description: "Halt a queued or running pulse, a module's planned pulses, or what activate started: /halt [pulse id | module | activated <name>]",
         handler: async (args, ctx) => {
             if (!ctx.hasUI)
                 return;
             const live = jobs.list().filter((job) => job.status === "running" || job.status === "queued");
             const deployed = runningDeployed();
+            const loop = workLoops.get(jobs)?.loop;
+            // A module's planned pulses, one line a module: halting one halts the module.
+            const plannedRows = loop?.planned() ?? [];
+            const planned = [...new Set(plannedRows.map((row) => row.module ?? ""))].filter((module) => module !== "");
             let id = args.trim();
             if (id === "") {
-                if (live.length === 0 && deployed.length === 0)
-                    return ctx.ui.notify("Nothing is regenerating or queued.", "info");
+                if (live.length === 0 && deployed.length === 0 && planned.length === 0)
+                    return ctx.ui.notify("Nothing is regenerating, queued or planned.", "info");
                 const label = (job) => `${job.id}  ${job.status.padEnd(8)} ${pulseName(job)}`;
-                const labels = [...live.map(label), ...deployed.map((item) => deployedLabel(item.name, item.url ?? item.command))];
+                const plannedLabel = (module) => {
+                    const rows = plannedRows.filter((row) => row.module === module);
+                    const waiting = rows.find((row) => row.id.endsWith("-waiting"));
+                    return `${module}  ${waiting !== undefined ? waiting.summary : `${rows.length} planned`} - halts the module`;
+                };
+                const labels = [...live.map(label), ...planned.map(plannedLabel), ...deployed.map((item) => deployedLabel(item.name, item.url ?? item.command))];
                 const picked = await ctx.ui.select("Halt which?", labels);
                 const job = live.find((candidate) => picked !== undefined && label(candidate) === picked);
+                const module = planned.find((name) => picked !== undefined && plannedLabel(name) === picked);
                 const server = deployed.find((item) => picked !== undefined && deployedLabel(item.name, item.url ?? item.command) === picked);
                 if (server !== undefined)
                     id = `activated ${server.name}`;
                 else if (job !== undefined)
                     id = job.id;
+                else if (module !== undefined)
+                    id = module;
                 else
                     return;
             }
@@ -1432,7 +1476,7 @@ function registerJobTools(pi, jobs, cwd) {
                 const stopped = await stopDeployed({ name });
                 return shownAfterCommand(pi, ctx, `/halt ${id}`, stopped.length > 0 ? `Halted ${stopped.join(", ")}.` : `Nothing activate started is running as ${name}.`, "info");
             }
-            ctx.ui.notify(stopJob(jobs, id), "info");
+            ctx.ui.notify(stopJob(jobs, id, undefined, loop), "info");
         },
     });
     // Debug mode, for the render agents started from now on - see debug-log.ts.
@@ -1508,6 +1552,7 @@ function registerJobTools(pi, jobs, cwd) {
         }
         needsLooking.delete(jobs);
         if (panel !== undefined) {
+            panel.keepChatFocus();
             panel.handle?.setHidden(false);
             panel.keys = true;
             panel.handle?.focus();
@@ -1515,7 +1560,21 @@ function registerJobTools(pi, jobs, cwd) {
         }
         // Not awaited: the panel lives on while the jobs it shows run.
         void ctx.ui.custom((tui, theme, _keybindings, done) => {
-            const close = () => done(undefined);
+            // What the chat shows when the panel takes the keys - its editor, or a pi dialog - for when it gives them back.
+            const focusedNow = () => tui.getFocusedComponent?.() ?? null;
+            let chatFocus = focusedNow();
+            const keepChatFocus = () => {
+                const focused = focusedNow();
+                if (focused !== null && focused !== component && !(focused instanceof QuestionDialog))
+                    chatFocus = focused;
+            };
+            // The keys back to the chat: to the question open there now, else to what it showed - never to a question answered
+            // while the panel was open.
+            const giveBack = () => entry.handle?.unfocus({ target: questionShown ?? chatFocus });
+            const close = () => {
+                giveBack();
+                done(undefined);
+            };
             panelTerminal = tui.terminal;
             let component;
             // Beside the chat: the chat drawn narrower, on the left, and a click on either side giving it the keys - undone
@@ -1548,10 +1607,11 @@ function registerJobTools(pi, jobs, cwd) {
             // Beside the chat, back to it: the chat has the keys, the panel stays.
             const toChat = () => {
                 entry.keys = false;
-                entry.handle?.unfocus();
+                giveBack();
                 tui.requestRender();
             };
             const toPanel = () => {
+                keepChatFocus();
                 entry.keys = true;
                 entry.handle?.focus();
                 tui.requestRender();
@@ -1604,7 +1664,7 @@ function registerJobTools(pi, jobs, cwd) {
                     return focused !== null && focused !== component;
                 },
             });
-            const entry = { view, close, keys: true };
+            const entry = { view, close, keepChatFocus, keys: true };
             panel = entry;
             layOut();
             // Every key goes to the panel while it shows, whatever has the focus: a question the chat model asks in the
@@ -2007,6 +2067,7 @@ function registerDeploy(pi, cwd, jobs, state) {
         cwd,
         state,
         jobs,
+        workLoop: () => workLoops.get(jobs)?.loop,
         defaultPlainFile: () => readProjectConfig(cwd).module,
     });
     for (const tool of tools)

package/dist/genome.js

@@ -185,7 +185,7 @@ export async function runSkill(opts) {
     // Built renders were lost with the process; queue what the specs hold that is not built.
     if (resumed !== undefined && opts.renderQueue !== undefined) {
         for (const file of plainFilesIn(opts.cwd))
-            void opts.renderQueue.bringUp(file).catch(() => undefined);
+            void opts.renderQueue.bringUp(file, { specChange: true }).catch(() => undefined);
     }
     if (liveStep !== undefined && liveProxy !== undefined) {
         const continuous = liveStep.gate.continuous;

package/dist/init-config.js

@@ -110,6 +110,7 @@ export function withModels(text, lines) {
 export const DEFAULTS = {
     conformanceTests: false,
     review: false,
+    mutationTesting: true,
     allowToStopJobs: true,
     releaseAfterPulse: false,
     testingScriptsRunOn: "in-place",
@@ -143,6 +144,10 @@ export function quickStartConfig(vendor = "other", bedrock) {
         "# Whether the code and its tests are reviewed once they pass - two reviews at most, the second weighed by the arbiter.",
         `review: ${DEFAULTS.review}`,
         "",
+        "# Whether the coding agent and the reviewer can put a bug in the code for one run of the unit tests (can_it_fail),",
+        "# to see that a test catches it - on a copy of the code, or in place and put back after.",
+        `mutation-testing: ${DEFAULTS.mutationTesting}`,
+        "",
         "# Whether turri stops a running pulse the spec has moved on from. false: it lands, the change regenerated on top.",
         `allow-to-stop-jobs: ${DEFAULTS.allowToStopJobs}`,
         "",

package/dist/loop-cli.js

@@ -4,6 +4,7 @@ import { resolve, sep } from "node:path";
 import { configForSpec, inheritModel, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, ROLE_THINKING, splitModelSpec, } from "./config.js";
 import { PACKAGE_ROOT } from "./environment.js";
 import { c } from "./module-report.js";
+import { describeTurnIncident, onModelEvent } from "./regenerate/activity.js";
 import { tryItCommand } from "./regenerate/delivery.js";
 import { describeDiagnosis, diagnoseFailure } from "./regenerate/diagnose.js";
 import { createJobRegistry, pulseName } from "./regenerate/jobs.js";
@@ -51,6 +52,7 @@ export async function runLoop(options) {
             ...(buildDir !== undefined ? { buildDir } : {}),
             conformanceTests: conformanceLabel(project.conformanceTests),
             review: project.review === true,
+            mutationTesting: project.mutationTesting !== false,
             models: reportModels(project, model),
         })
         : undefined;
@@ -85,9 +87,19 @@ async function runLoopReporting(options) {
             console.log(`${mark} ${job.id} ${pulseName(job)} - ${job.status}`);
             if (job.status !== "succeeded")
                 console.log(c.dim((job.announce ?? job.report ?? job.error ?? "").trim()));
+            // Its report is not printed when it succeeds, and nobody is asked here: the spec gaps its agents met are said.
+            else
+                for (const gap of job.details?.specGaps ?? [])
+                    console.log(c.yellow(`  spec gap: ${gap.question}`), c.dim(`Meanwhile: ${gap.assumption}`));
             report?.write();
         },
     });
+    // A provider failing and waited out, a turn turri ended itself: said as they happen, not left in the job logs alone.
+    onModelEvent((event) => {
+        const line = describeTurnIncident(event);
+        if (line !== undefined)
+            console.log(c.yellow(`  ${event.job !== undefined ? `${event.job}: ` : ""}${line}`));
+    });
     const planner = modelSpec(projectModels(project).harness);
     const loop = createWorkLoop({
         registry,
@@ -236,7 +248,7 @@ function reportModels(project, model) {
 }
 /**
  * The options every command that regenerates takes for a headless run: `--report` and `--build-dir`, and the config's
- * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review` and, where
+ * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review`, `--mutation-testing` and, where
  * `conformance` is true, `--conformance-tests` - read as if config.turri.yaml had them. Exits on a value it cannot read.
  */
 export function headlessOptions(options, conformance) {