@turri-dev/cli 0.1.4-next.246fd84 → 0.1.4-next.5a94e68

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,11 +90,12 @@ 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) => {
+            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) => {
@@ -108,7 +109,7 @@ aside) {
                 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 };
@@ -327,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;
@@ -610,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);
@@ -652,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;
             }
@@ -668,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);

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) {

package/dist/loop-tools.js

@@ -110,6 +110,10 @@ function plainFileOf(cwd, given, what) {
 export function asksFromScratch(words) {
     return FROM_SCRATCH.test(words);
 }
+/** Whether a /regenerate asking for its module from scratch asks for its whole requires chain with it. */
+export function asksWholeChain(words) {
+    return /\bchain\b|\bevery module\b|\ball (the )?modules\b/i.test(words);
+}
 const FROM_SCRATCH = /\b(from (scratch|nothing|zero|the (start|beginning|ground up))|start(ing)? (it )?(over|afresh)|afresh|anew|clean slate|(delete|wipe|remove|drop|throw away)\b.{0,30}\b(module|code|codebase|everything|all of it))/i;
 /** regenerate: regenerate a module's code up to its spec as it is now. */
 export function regenerateTool(options) {
@@ -131,6 +135,7 @@ export function regenerateTool(options) {
             "A change to a file the spec links - an API surface, a mapping document - is a change to the spec: regenerate sees it by itself, and regenerates every functional spec that uses what links it.",
             "Never stop pulses and start them again yourself to follow a spec change: regenerate does it.",
             "Set from_scratch only when the user asks for the module to be regenerated from scratch - started over, its code deleted - in this conversation, or agrees to it when a module's status says it has to start over: never to fix a pulse that did not land.",
+            'from_scratch "module" takes out the code where the module is built; the modules below keep theirs, and the module starts from a copy of the code below it. "chain" takes out every codebase of its requires chain, the base\'s too, and builds all of it again from the bottom: use it after modules were split, merged or moved (refactor-module), or when the user asks for the whole chain.',
         ],
         parameters: Type.Object({
             plain_file: Type.Optional(Type.String({ description: "Path to the .plain file. Omitted: the module the project's config.turri.yaml names" })),
@@ -139,8 +144,9 @@ export function regenerateTool(options) {
             functionalities: Type.Optional(Type.Array(Type.String(), {
                 description: "Functional specs already built, by id, to regenerate though their spec did not change. Omitted: what the spec now differs from the code in",
             })),
-            from_scratch: Type.Optional(Type.Boolean({
-                description: "Only when the user asks for it: the module's code and conformance tests deleted - committed first, so its lineage keeps them - and the whole module regenerated from its spec",
+            from_scratch: Type.Optional(Type.Union([Type.Literal("module"), Type.Literal("chain")], {
+                description: "Only when the user asks for it: the module's code and conformance tests deleted - committed first, so its lineage keeps them - and the whole module regenerated from its spec. " +
+                    '"chain": every module of its requires chain too, built again from the bottom',
             })),
             model: MODEL_PARAM,
             wait: WAIT_PARAM,
@@ -151,15 +157,15 @@ export function regenerateTool(options) {
             if (!check.ok)
                 throw new Error(`${relative(options.cwd, plainFile) || plainFile} does not parse, so nothing can be regenerated from it yet: ${check.error}`);
             const again = given.functionalities ?? [];
-            if (again.length > 0 && given.from_scratch === true)
+            if (again.length > 0 && given.from_scratch !== undefined)
                 throw new Error("Name functionalities or set from_scratch, not both: from scratch regenerates every one of them.");
             // Named functionalities are work on functionalities, as engine chooses a model for it; the rest, spec changes.
             const work = again.length > 0 ? "functionalities" : "spec_changes";
             const model = options.model !== undefined ? options.model(ctx, plainFile, given.model, work) : given.model;
             const loop = options.loop(ctx);
             const request = { ...(model !== undefined ? { model } : {}), ...(given.guidance !== undefined ? { guidance: given.guidance } : {}) };
-            const statuses = given.from_scratch === true
-                ? await loop.fromScratch(plainFile, request)
+            const statuses = given.from_scratch !== undefined
+                ? await loop.fromScratch(plainFile, { ...request, chain: given.from_scratch === "chain" })
                 : again.length > 0
                     ? await loop.regenerateAgain(plainFile, again, request)
                     : await loop.bringUp(plainFile, request);

package/dist/pi.js

@@ -4,6 +4,7 @@ import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRegistry,
 import { loadRules, renderRulesBlock } from "./rules.js";
 import { inheritModel, stackOf, readProjectConfig, ROLE_THINKING, roleModel, roleTurnLimitMs, splitModelSpec } from "./config.js";
 import { maskToolResults } from "./regenerate/masking.js";
+import { withListArguments } from "./regenerate/list-arguments.js";
 import { checkAgainstScript, ENVIRONMENT_ERROR_TOOL, EnvironmentError, environmentErrorTool, sandboxGapOf } from "./regenerate/environment-error.js";
 import { MODULES_DIR, projectRootOf, sessionsDir } from "./regenerate/paths.js";
 import { currentStopSignal, describeToolCall, describeToolResult, JobStoppedError, shownName, reportActivity, reportNow, reportAgent, reportTranscript, reportModelEvent, reportUsage, } from "./regenerate/activity.js";
@@ -146,6 +147,19 @@ export class ProviderError extends Error {
         this.name = "ProviderError";
     }
 }
+/** Why turri itself ended a session's turn under way: the abort that comes back is its own, not the provider failing. */
+const harnessStops = new WeakMap();
+/**
+ * End the agent's turn, turri's own doing - it is going round in a circle, its time is up. The turn ends as any turn
+ * does: what the agent said stands, and the harness goes on from there. Never a provider error.
+ */
+export function stopTurn(session, reason) {
+    if (session === undefined || harnessStops.has(session))
+        return;
+    harnessStops.set(session, reason);
+    reportModelEvent({ kind: "stopped", ...modelEventOf(session), reason });
+    void session.abort();
+}
 /**
  * Run one turn and return the assistant's text, streaming deltas to `onDelta`.
  *
@@ -212,17 +226,32 @@ async function askUnrestricted(session, text, onDelta) {
         catch (error) {
             if (!(error instanceof ProviderError) || !TRANSIENT_PROVIDER_ERROR.test(error.message) || attempt >= PROVIDER_RETRIES)
                 throw error;
-            const wait = PROVIDER_RETRY_DELAY_MS * 2 ** attempt;
-            reportActivity(`  the model provider is failing for now - trying again in ${Math.round(wait / 1000)}s (${attempt + 1} of ${PROVIDER_RETRIES})`);
-            debugLogOf(session)?.note(`provider failing - trying again in ${Math.round(wait / 1000)}s: ${error.message.slice(0, 200)}`);
+            const wait = providerRetryDelay(attempt);
+            const shown = `${Math.round(wait / 1000)}s (${attempt + 1} of ${PROVIDER_RETRIES})`;
+            reportActivity(`  the model provider is failing for now - trying again in ${shown}`);
+            reportNow(`the model provider is failing - trying again in ${shown}`);
+            reportModelEvent({ kind: "provider_retry", ...modelEventOf(session), error: error.message, attempt: attempt + 1, of: PROVIDER_RETRIES, waitMs: wait });
+            debugLogOf(session)?.note(`provider failing - trying again in ${shown}: ${error.message.slice(0, 200)}`);
             await waitOrStop(wait);
+            reportNow(undefined);
             prompt = "Carry on where you were: the model provider failed part-way through your last turn.";
         }
     }
 }
-/** How many times, after pi's own retries, a turn whose provider failed for a moment is tried again - and the first wait, doubled each time. */
-export const PROVIDER_RETRIES = 3;
+/**
+ * How many times, after pi's own retries, a turn whose provider failed for a moment is tried again; the first wait,
+ * doubled each time up to the longest - 15s, 30s, 1m, 2m, 4m, 5m: an outage of about 13 minutes is waited out.
+ */
+export const PROVIDER_RETRIES = 6;
 export const PROVIDER_RETRY_DELAY_MS = Number(process.env.TURRI_PROVIDER_RETRY_DELAY ?? 15) * 1000;
+export const PROVIDER_RETRY_MAX_DELAY_MS = 20 * PROVIDER_RETRY_DELAY_MS;
+/** The wait before try `attempt + 1`: doubled each time, up to the longest, with a tenth either way so parallel jobs do not all come back at once. */
+export function providerRetryDelay(attempt, random = Math.random) {
+    const base = Math.min(PROVIDER_RETRY_DELAY_MS * 2 ** attempt, PROVIDER_RETRY_MAX_DELAY_MS);
+    return Math.round(base * (0.9 + 0.2 * random()));
+}
+/** How long a request to the model may go without anything coming back before the provider is said to be stalling; 0 never. */
+export const PROVIDER_STALL_MS = Number(process.env.TURRI_PROVIDER_STALL ?? 120) * 1000;
 /** A provider error that passes: overloaded, rate limited, unreachable, timed out. */
 const TRANSIENT_PROVIDER_ERROR = /\b(429|500|502|503|504|529)\b|overloaded|high demand|rate.?limit|too many requests|unavailable|fetch failed|network|connection|timed? ?out|ECONNRESET|socket|terminated/i;
 /** Wait, unless the job is stopped first. */
@@ -251,7 +280,7 @@ async function askOnce(session, text, onDelta) {
     // Calls to one tool failing one after another - arguments it refuses, or errors - with nothing going through.
     let failing = 0;
     let failingTool;
-    let stoppedFailing = false;
+    harnessStops.delete(session);
     reportNow("waiting for the model");
     // Every entry says which agent it is from, and what it runs on - for reading one agent at a time.
     const agent = agentOf(session);
@@ -263,7 +292,30 @@ async function askOnce(session, text, onDelta) {
     if (agent !== undefined)
         reportAgent({ label: agent.label, ...(agent.model !== undefined ? { model: agent.model } : {}), turns: 1 });
     reportModelEvent({ kind: "turn", ...modelEventOf(session) });
+    // The provider stalling: a request to the model that nothing has come back on - not a token, not an error - for
+    // long. Said once for each silence; the turn goes on waiting, its own time limit ending it if it must.
+    let toolsRunning = 0;
+    let stall;
+    const watchForStall = (afterMs = PROVIDER_STALL_MS) => {
+        if (stall !== undefined)
+            clearTimeout(stall);
+        stall = toolsRunning > 0 || PROVIDER_STALL_MS <= 0 ? undefined : setTimeout(() => {
+            reportModelEvent({ kind: "provider_stall", ...modelEventOf(session), waitMs: PROVIDER_STALL_MS });
+            debugLogOf(session)?.note(`the provider has sent nothing back for ${seconds(PROVIDER_STALL_MS)}`);
+        }, afterMs);
+    };
     const unsubscribe = session.subscribe((event) => {
+        if (event.type === "tool_execution_start")
+            toolsRunning += 1;
+        if (event.type === "tool_execution_end")
+            toolsRunning = Math.max(0, toolsRunning - 1);
+        // pi tries a failed request again itself first: the provider failing is said then, not only once pi gives up.
+        if (event.type === "auto_retry_start") {
+            reportModelEvent({ kind: "provider_retry", ...modelEventOf(session), error: event.errorMessage, attempt: event.attempt, of: event.maxAttempts, waitMs: event.delayMs });
+            watchForStall(event.delayMs + PROVIDER_STALL_MS);
+        }
+        else
+            watchForStall();
         if (event.type === "message_update") {
             const update = event.assistantMessageEvent;
             if (update.type === "text_delta") {
@@ -308,14 +360,13 @@ async function askOnce(session, text, onDelta) {
         if (event.type === "tool_execution_end") {
             failing = event.isError ? (event.toolName === failingTool ? failing + 1 : 1) : 0;
             failingTool = event.isError ? event.toolName : undefined;
-            if (failing >= FAILURES_BEFORE_STOP && !stoppedFailing) {
+            if (failing >= FAILURES_BEFORE_STOP && !harnessStops.has(session)) {
                 // A call its tool refuses never reaches the tool, so no guard on the tools sees it: an agent can
                 // make the same bad call, worded a little differently, thousands of times. Its turn ends here, and
                 // the harness goes on from there, as after any turn.
-                stoppedFailing = true;
                 reportActivity(`  stopped the agent's turn: ${failing} ${shownName(event.toolName)} calls failed in a row`);
                 debugLogOf(session)?.note(`turn stopped: ${failing} ${event.toolName} calls failed in a row`);
-                void session.abort();
+                stopTurn(session, `${failing} ${shownName(event.toolName)} calls failed in a row`);
             }
             const output = resultText(event.result);
             transcript({ kind: "result", text: clipText(output, MAX_TOOL_RESULT), error: event.isError, full: output });
@@ -376,7 +427,7 @@ async function askOnce(session, text, onDelta) {
         stopped = true;
         reportActivity(`  stopped the agent's turn: its ${formatLimit(limitMs)} are up`);
         debug?.note(`turn stopped: its ${formatLimit(limitMs)} are up${how}`);
-        void session.abort();
+        stopTurn(session, `its ${formatLimit(limitMs)} were up`);
     };
     const atNextRequest = timed
         ? session.subscribe((event) => {
@@ -392,6 +443,7 @@ async function askOnce(session, text, onDelta) {
     }
     // What the model is sent, and only that: its task is its system prompt, which the log already holds whole.
     debug?.prompt(text);
+    watchForStall();
     try {
         // Its images, when its conversation does not hold them: the first turn, and the first after a compaction.
         const images = sessionImages.get(session);
@@ -412,19 +464,24 @@ async function askOnce(session, text, onDelta) {
             clearTimeout(timer);
         if (backstop !== undefined)
             clearTimeout(backstop);
+        if (stall !== undefined)
+            clearTimeout(stall);
         atNextRequest?.();
         unsubscribe();
         stop?.removeEventListener("abort", onStop);
         reportNow(undefined);
     }
-    if (stopped)
-        out = `${out.trim()}\n\n[the turn was stopped: its ${formatLimit(limitMs)} were up]`.trim();
+    // turri ended the turn itself - its time was up, the agent went round in a circle: the abort that ended it is its own.
+    const stoppedFor = harnessStops.get(session);
+    harnessStops.delete(session);
+    if (stoppedFor !== undefined)
+        out = `${out.trim()}\n\n[the turn was stopped: ${stoppedFor}]`.trim();
     if (stop?.aborted) {
         debug?.note(`turn stopped on request after ${seconds(Date.now() - turnStarted)}`);
         throw new JobStoppedError();
     }
-    // A turn ended for its time is ended, whatever the provider was doing then.
-    if (providerError !== undefined && !stopped) {
+    // A turn turri ended is ended, whatever the provider was doing then: what comes back of the abort is not the provider failing.
+    if (providerError !== undefined && stoppedFor === undefined) {
         debug?.note(`turn ended with a provider error after ${seconds(Date.now() - turnStarted)}: ${providerError}`);
         throw new ProviderError(`${session.model?.id ?? "model"}: ${providerError}`);
     }
@@ -614,7 +671,7 @@ export function guardRepeats(tools, session, budget) {
                 refused += 1;
                 if (refused > REFUSED_BEFORE_STOP) {
                     reportActivity(`  stopped the agent's turn: ${refused} calls to tools this turn does not have`);
-                    void current?.abort();
+                    stopTurn(current, `${refused} calls to tools this turn does not have`);
                     throw new Error(`Stopped: ${refused} calls to tools this turn does not have.`);
                 }
                 throw new Error(`Not run: your work is done and checked - this turn is for ${[...only].join(" and ")} alone, and nothing else is ` +
@@ -624,7 +681,7 @@ export function guardRepeats(tools, session, budget) {
             if (budget !== undefined && !budget.finish.includes(tool.name) && calls > budget.calls) {
                 if (calls > budget.calls * 2) {
                     reportActivity(`  stopped the agent's turn: ${calls} tool calls, past its budget of ${budget.calls}`);
-                    void session()?.abort();
+                    stopTurn(session(), `${calls} tool calls, past its budget of ${budget.calls}`);
                     throw new Error(`Stopped: ${calls} tool calls, past the budget of ${budget.calls}.`);
                 }
                 throw new Error(`Not run: you have made ${budget.calls} tool calls, which is all you have. Decide now with what you know: call ` +
@@ -652,7 +709,7 @@ export function guardRepeats(tools, session, budget) {
             }
             if (repeats > REPEATS_BEFORE_STOP) {
                 reportActivity(`  stopped the agent's turn: it made the same ${tool.name} call ${repeats} times with nothing changed`);
-                void session()?.abort();
+                stopTurn(session(), `the same ${tool.name} call ${repeats} times with nothing changed`);
                 throw new Error(`Stopped: the same ${tool.name} call ${repeats} times with nothing changed.`);
             }
             if (repeats > REPEATS_ALLOWED) {
@@ -695,7 +752,7 @@ export async function createExecutor(opts) {
         modelRuntime: await subAgentModelRuntime(),
         tools: hasShell ? [...opts.tools, ENVIRONMENT_ERROR_TOOL] : opts.tools,
         // What an agent is shown never holds a credential the project passed: each value is its name (masking.ts).
-        customTools: guardRepeats(maskToolResults(withEnvironmentErrors), () => session, opts.budget),
+        customTools: guardRepeats(maskToolResults(withListArguments(withEnvironmentErrors)), () => session, opts.budget),
         sessionManager,
         resourceLoader: await subAgentResources(opts.cwd, opts.rules === true, [opts.system, opts.task].filter((part) => part !== undefined && part !== "").join("\n\n") || undefined),
     });
@@ -814,7 +871,7 @@ export async function createJudge(opts) {
         model,
         modelRuntime,
         tools: [...(opts.extraTools ?? []), "submit_verdict"],
-        customTools: [opts.verdictTool],
+        customTools: withListArguments([opts.verdictTool]),
         sessionManager: SessionManager.inMemory(opts.cwd),
         // Judges assess specs against the rules, so they have them too.
         resourceLoader: await subAgentResources(opts.cwd, true, opts.task),

package/dist/question-dialog.js

@@ -25,6 +25,7 @@ export class QuestionDialog {
         }
         else {
             this.input = undefined;
+            this.selected = Math.min(Math.max(0, options.selected ?? 0), options.options.length - 1);
         }
     }
     get focused() {