@turri-dev/cli 0.1.23 → 0.1.24-next.2b2f203

package/dist/extension.d.ts

@@ -51,11 +51,17 @@ export declare function sessionLoop(session: TurriCore): WorkLoop;
 /**
  * What a slash command showed the person: kept in the chat, where they read it, and put in the conversation as well -
  * unseen there - so that when they speak of it next ("fix it"), the agent knows what they saw. A command runs outside
- * the agent's turns, and a notification is gone in seconds and reaches no model.
+ * the agent's turns, and a notification is gone in seconds and reaches no model. Given `react`, the agent is started on
+ * it too - at once when it is idle, else once its turn ends - told what to do with it.
  */
 export declare function shownAfterCommand(pi: ExtensionAPI, ctx: ExtensionContext, command: string, text: string, level: NonNullable<CommandOutcome["level"]>, 
 /** The command is in the chat already, above it (echoCommand): the text alone. */
-echoed?: boolean): void;
+echoed?: boolean, react?: string): void;
+/**
+ * What the agent does once /regenerate has started pulses: a command's output alone leaves the chat silent, and the
+ * person wondering whether to wait. It says what runs, and that they need not - and starts nothing itself.
+ */
+export declare const COMMAND_STARTED_REACTION: string;
 export declare const COMMAND_OUTCOME = "turri_command_outcome";
 interface CommandOutcome {
     command: string;

package/dist/extension.js

@@ -949,7 +949,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, its whole chain too when asked: /regenerate [module | file.plain] [functionality ...] [from scratch [whole chain]] [how to cut the work]",
+        description: "Regenerate a module from its ***plain 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);
@@ -1000,8 +1000,8 @@ function registerRegenerate(pi, cwd, jobs) {
             }
             if (scratch && ctx.hasUI) {
                 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.`);
+                    ? `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 ***plain, 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 ***plain.`);
                 if (!agreed)
                     return;
             }
@@ -1028,10 +1028,12 @@ function registerRegenerate(pi, cwd, jobs) {
                             ? loop.regenerateAgain(target, again, request)
                             : loop.bringUp(target, request));
                     // Nothing to do: say how to build it again anyway.
-                    const hint = statuses.length > 0 && statuses.every(isUpToDate)
+                    const upToDate = statuses.length > 0 && statuses.every(isUpToDate);
+                    const hint = upToDate
                         ? `\nTo regenerate parts of it anyway, name their functionalities - /regenerate ${basename(target)} 2.1 - or start over with /regenerate ${basename(target)} from scratch.`
                         : "";
-                    say(describeModules(statuses) + hint, "info");
+                    // Pulses started: the agent says so, and that the person need not wait - a plan alone leaves the chat silent.
+                    shownAfterCommand(pi, ctx, command, describeModules(statuses) + hint, "info", true, upToDate ? undefined : COMMAND_STARTED_REACTION);
                 }
                 catch (error) {
                     say(error instanceof Error ? error.message : String(error), "error");
@@ -1045,11 +1047,12 @@ function registerRegenerate(pi, cwd, jobs) {
 /**
  * What a slash command showed the person: kept in the chat, where they read it, and put in the conversation as well -
  * unseen there - so that when they speak of it next ("fix it"), the agent knows what they saw. A command runs outside
- * the agent's turns, and a notification is gone in seconds and reaches no model.
+ * the agent's turns, and a notification is gone in seconds and reaches no model. Given `react`, the agent is started on
+ * it too - at once when it is idle, else once its turn ends - told what to do with it.
  */
 export function shownAfterCommand(pi, ctx, command, text, level, 
 /** The command is in the chat already, above it (echoCommand): the text alone. */
-echoed = false) {
+echoed = false, react) {
     try {
         pi.appendEntry(COMMAND_OUTCOME, { command, text, level, ...(echoed ? { echoed } : {}) });
     }
@@ -1058,8 +1061,19 @@ echoed = false) {
         if (ctx.hasUI)
             ctx.ui.notify(text, level);
     }
-    void pi.sendMessage({ customType: COMMAND_OUTCOME, content: `The person ran ${command}, and was shown:\n${text}`, display: false });
+    const content = `The person ran ${command}, and was shown:\n${text}${react !== undefined ? `\n\n${react}` : ""}`;
+    if (react === undefined)
+        void pi.sendMessage({ customType: COMMAND_OUTCOME, content, display: false });
+    else
+        void pi.sendMessage({ customType: COMMAND_OUTCOME, content, display: false }, { triggerTurn: true, deliverAs: "followUp" });
 }
+/**
+ * What the agent does once /regenerate has started pulses: a command's output alone leaves the chat silent, and the
+ * person wondering whether to wait. It says what runs, and that they need not - and starts nothing itself.
+ */
+export const COMMAND_STARTED_REACTION = "My pulses are regenerating from the person's /regenerate, in the background. Tell the person, in a line or two, what " +
+    "runs and what is planned - and that the two of us can go on with the ***plain, or anything else, meanwhile: they need " +
+    "not wait for it. Start nothing for it: no regenerate, no check, no release - its end is told when it comes.";
 export const COMMAND_OUTCOME = "turri_command_outcome";
 /** Longer than a frame of the TUI's (16ms): an entry appended before it is drawn by its end. */
 const ONE_FRAME_MS = 20;

package/dist/regenerate/job-panel.js

@@ -215,7 +215,7 @@ export function jobPanelLines(jobs, options = {}) {
         if (lines.length > 0 && running.length > 0)
             lines.push("");
         lines.push(`${spinner(now)} ${job.module ?? job.summary} · planning the pulses · ${formatElapsed(now - job.planning.since)}`);
-        lines.push("    the planner is cutting the work into pulses - the first starts once it is done");
+        lines.push("    working out what to regenerate and cutting it into pulses - the first starts once it is done");
     }
     // Always a line of help: how to see more here, and how to inspect the jobs in the side panel.
     if (options.hints === false) {

package/dist/regenerate/loop.d.ts

@@ -346,7 +346,7 @@ export declare function createWorkLoop(options: {
     dryRun?: boolean;
 }): WorkLoop;
 /** Why nothing runs in a codebase whose code - and conformance tests, where they are wanted - is built from its spec as it is. */
-export declare const UP_TO_DATE = "built from the spec as it is";
+export declare const UP_TO_DATE = "built from the ***plain as it is";
 /** The codebases the loop looks after, as the person reads them: what runs, what is planned after it, and why nothing does. */
 /**
  * The coding agent's task for a dry run's first job, built as the render builds it - and all it did rolled back. Not for

package/dist/regenerate/loop.js

@@ -780,6 +780,28 @@ export function createWorkLoop(options) {
     };
     /** The files asked for, each with how: what the loop brings up, worked out again each look. */
     const asked = new Map();
+    /**
+     * The modules asked for whose plan is not made yet - their code being deleted, what is left being worked out, the
+     * planner not started - by name, with since when: each shows as being planned from the moment it is asked for, not
+     * only once the planner runs, so the person never looks at nothing.
+     */
+    const preparing = new Map();
+    const preparingFor = async (plainFile, work) => {
+        const name = basename(plainFile).replace(/\.plain$/, "");
+        if (preparing.has(name))
+            return work();
+        preparing.set(name, { since: Date.now(), plainFile: resolve(options.cwd, plainFile) });
+        options.registry.notify?.();
+        // A frame to draw it in before what follows: deleting a codebase and committing it hold the event loop.
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        try {
+            return await work();
+        }
+        finally {
+            preparing.delete(name);
+            options.registry.notify?.();
+        }
+    };
     /** The codebases the requests bring up now - where each module's code lives, and what is to be built on it. */
     const active = () => {
         const states = new Set();
@@ -973,14 +995,28 @@ export function createWorkLoop(options) {
         startJob(state, spec, from, state.plan.jobs[0]);
     };
     const statusOf = (state) => describe(state).status;
+    /** The modules asked for that the loop holds nothing of yet - turri just opened, say: their code being planned all the same. */
+    const preparingAlone = () => {
+        const held = new Set(order.map((key) => tipEntry(modules.get(key)).moduleName));
+        return [...preparing]
+            .filter(([name]) => !held.has(name))
+            .map(([name, { since, plainFile }]) => ({
+            module: name,
+            plainFile,
+            planned: [{ title: "the work", cases: { fresh: false, add: [], patch: [], again: [], delete: [], mechanical: false }, track: "code", planning: true }],
+            since,
+        }));
+    };
     /** A codebase's status, and beside each job it lists as planned, the planned job it is - none for one being planned or scheduled. */
     const describe = (state) => inStack(state, () => describeIn(state));
     const describeIn = (state) => {
         // What runs next: the code's jobs, then the conformance tests' - the module's, once its code is built - the running job first.
         const running = state.running?.planned;
         const own = (jobs) => (jobs ?? []).filter((job) => job !== running);
-        // A track being planned again shows as that, not as its plan before.
-        const replanning = state.running === undefined ? state.planning : undefined;
+        // A track being planned again shows as that, not as its plan before - and a module asked for, from that moment, as
+        // its code being planned: its code deleted, what is left worked out, before the planner runs.
+        const planningTrack = state.running === undefined ? (state.planning ?? (preparing.has(tipEntry(state).moduleName) ? "code" : undefined)) : undefined;
+        const replanning = planningTrack;
         const jobs = [
             ...(running !== undefined ? [running] : []),
             ...(replanning === "code" ? [] : own(state.plan?.jobs)),
@@ -994,18 +1030,18 @@ export function createWorkLoop(options) {
             : [{ title: group.specs.map((touched) => `fs ${touched.frid}`).join(", "), cases: { fresh: false, add: group.specs, patch: [], again: [], delete: [], mechanical: false }, track: "conformance", waitsFor: group.unbuilt }]);
         // Being planned, nothing running: what is next - for the conformance tests, the groups chosen that it plans - not nothing.
         const together = (state.together ?? []).flat().map((touched) => `fs ${touched.frid}`);
-        const planningNow = state.running === undefined && state.planning !== undefined
+        const planningNow = planningTrack !== undefined
             ? [
                 {
-                    title: state.planning === "conformance" ? (together.length > 0 ? together.join(", ") : "the conformance tests") : "the work",
+                    title: planningTrack === "conformance" ? (together.length > 0 ? together.join(", ") : "the conformance tests") : "the work",
                     cases: { fresh: false, add: [], patch: [], again: [], delete: [], mechanical: false },
-                    track: state.planning,
+                    track: planningTrack,
                     planning: true,
                 },
             ]
             : [];
         // The module's conformance tests, wanted for all of it while code is still to build: planned once it is built, shown now.
-        const codeToBuild = lastCode !== -1 || (state.running === undefined && state.planning === "code");
+        const codeToBuild = lastCode !== -1 || planningTrack === "code";
         const testReqs = (state.seen?.tree[TEST_REQUIREMENTS] ?? []).length > 0;
         const plainFile = tipEntry(state).plainFile;
         const wholeModule = (state.conformance !== undefined && state.conformance.chosen === undefined) || (configConformance(plainFile) && !configChosen(plainFile));
@@ -1073,70 +1109,76 @@ export function createWorkLoop(options) {
     };
     const loop = {
         async bringUp(plainFile, given = {}) {
-            const { specChange, ...request } = given;
-            const files = codebasesOf(resolve(options.cwd, plainFile));
-            for (const file of files)
-                asked.set(file, { ...asked.get(file), ...request });
-            // Asked for, it is built with its stack - the one the call names, its own, or the one chosen now - pinned, whatever
-            // is chosen later; a spec change keeps the one it was asked for with.
-            const pin = { keep: specChange === true };
-            const states = withParseCache(() => files.flatMap((file) => chainsFor(file).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request, pin)))));
-            // Asked again, a halted codebase is tried again - one the person halted too, unless only its spec changed.
-            for (const state of states) {
-                state.halted = undefined;
-                if (specChange !== true)
-                    state.held = undefined;
-            }
-            await tick();
-            return [...new Set(states)].map(statusOf);
+            const now = async () => {
+                const { specChange, ...request } = given;
+                const files = codebasesOf(resolve(options.cwd, plainFile));
+                for (const file of files)
+                    asked.set(file, { ...asked.get(file), ...request });
+                // Asked for, it is built with its stack - the one the call names, its own, or the one chosen now - pinned, whatever
+                // is chosen later; a spec change keeps the one it was asked for with.
+                const pin = { keep: specChange === true };
+                const states = withParseCache(() => files.flatMap((file) => chainsFor(file).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request, pin)))));
+                // Asked again, a halted codebase is tried again - one the person halted too, unless only its spec changed.
+                for (const state of states) {
+                    state.halted = undefined;
+                    if (specChange !== true)
+                        state.held = undefined;
+                }
+                await tick();
+                return [...new Set(states)].map(statusOf);
+            };
+            // Asked for, it shows as being planned at once; a spec change is looked at quietly, as every change is.
+            return given.specChange === true ? now() : preparingFor(plainFile, now);
         },
         async regenerateAgain(plainFile, given, request = {}) {
-            const frids = [...new Set(Array.isArray(given) ? given : [given])];
-            const asked = resolve(options.cwd, plainFile);
-            const own = resolveRequiresChain(asked, [], undefined, { allowNoFunctionalities: true });
-            const module = tipOf(own).moduleName;
-            const chains = chainsFor(asked);
-            for (const chain of chains) {
-                const tip = tipOf(chain);
-                if (modules.get(tip.buildDir)?.running !== undefined)
-                    throw new Error(`${tip.moduleName} has a pulse running: ask again once it is done.`);
-            }
-            const found = new Set();
-            for (const chain of chains) {
-                const tip = tipOf(chain);
-                const record = readRecord(tip.buildDir);
-                if (record === null)
-                    continue;
-                const section = tip.moduleName === module ? FUNCTIONAL_REQUIREMENTS : REQUIRED_FUNCTIONAL_SPECS;
-                const items = record[section] ?? [];
-                const named = (item, index) => section === FUNCTIONAL_REQUIREMENTS ? String(index + 1) : item.module === module ? (item.frid ?? "") : "";
-                const taken = items.flatMap((item, index) => (frids.includes(named(item, index)) ? [named(item, index)] : []));
-                if (taken.length === 0)
-                    continue;
-                for (const frid of taken)
-                    found.add(frid);
-                const marked = items.map((item, index) => (frids.includes(named(item, index)) ? { ...item, [REGENERATE_AGAIN]: true } : item));
-                writeCodeRecord(tip.buildDir, { ...record, [section]: marked });
-                // Its conformance tests were written against the code being replaced: marked with it, they are written again -
-                // checked against the new code, and rewritten where they relied on what the old code chose - once it lands.
-                if (section === FUNCTIONAL_REQUIREMENTS) {
-                    const testsDir = conformanceDirFor(tip.moduleName, modulesRoot(projectDirOf(tip.plainFile)));
-                    const tests = readRecord(testsDir);
-                    const tested = tests?.[FUNCTIONAL_REQUIREMENTS] ?? [];
-                    if (tested.some((item) => item.frid !== undefined && taken.includes(item.frid))) {
-                        const again = tested.map((item) => (item.frid !== undefined && taken.includes(item.frid) ? { ...item, [REGENERATE_AGAIN]: true } : item));
-                        writeTestsRecord(testsDir, { ...tests, [FUNCTIONAL_REQUIREMENTS]: again });
+            return preparingFor(plainFile, async () => {
+                const frids = [...new Set(Array.isArray(given) ? given : [given])];
+                const asked = resolve(options.cwd, plainFile);
+                const own = resolveRequiresChain(asked, [], undefined, { allowNoFunctionalities: true });
+                const module = tipOf(own).moduleName;
+                const chains = chainsFor(asked);
+                for (const chain of chains) {
+                    const tip = tipOf(chain);
+                    if (modules.get(tip.buildDir)?.running !== undefined)
+                        throw new Error(`${tip.moduleName} has a pulse running: ask again once it is done.`);
+                }
+                const found = new Set();
+                for (const chain of chains) {
+                    const tip = tipOf(chain);
+                    const record = readRecord(tip.buildDir);
+                    if (record === null)
+                        continue;
+                    const section = tip.moduleName === module ? FUNCTIONAL_REQUIREMENTS : REQUIRED_FUNCTIONAL_SPECS;
+                    const items = record[section] ?? [];
+                    const named = (item, index) => section === FUNCTIONAL_REQUIREMENTS ? String(index + 1) : item.module === module ? (item.frid ?? "") : "";
+                    const taken = items.flatMap((item, index) => (frids.includes(named(item, index)) ? [named(item, index)] : []));
+                    if (taken.length === 0)
+                        continue;
+                    for (const frid of taken)
+                        found.add(frid);
+                    const marked = items.map((item, index) => (frids.includes(named(item, index)) ? { ...item, [REGENERATE_AGAIN]: true } : item));
+                    writeCodeRecord(tip.buildDir, { ...record, [section]: marked });
+                    // Its conformance tests were written against the code being replaced: marked with it, they are written again -
+                    // checked against the new code, and rewritten where they relied on what the old code chose - once it lands.
+                    if (section === FUNCTIONAL_REQUIREMENTS) {
+                        const testsDir = conformanceDirFor(tip.moduleName, modulesRoot(projectDirOf(tip.plainFile)));
+                        const tests = readRecord(testsDir);
+                        const tested = tests?.[FUNCTIONAL_REQUIREMENTS] ?? [];
+                        if (tested.some((item) => item.frid !== undefined && taken.includes(item.frid))) {
+                            const again = tested.map((item) => (item.frid !== undefined && taken.includes(item.frid) ? { ...item, [REGENERATE_AGAIN]: true } : item));
+                            writeTestsRecord(testsDir, { ...tests, [FUNCTIONAL_REQUIREMENTS]: again });
+                        }
                     }
+                    recordHistory(tip.buildDir, `${module} functional spec${taken.length === 1 ? "" : "s"} ${taken.join(", ")} to regenerate again`);
                 }
-                recordHistory(tip.buildDir, `${module} functional spec${taken.length === 1 ? "" : "s"} ${taken.join(", ")} to regenerate again`);
-            }
-            const missing = frids.filter((frid) => !found.has(frid));
-            if (found.size === 0)
-                throw new Error(`${module} has no functional spec ${missing.join(", ")} built anywhere, so there is nothing to regenerate again: regenerate builds what is not built.`);
-            const statuses = await loop.bringUp(plainFile, request);
-            if (missing.length > 0)
-                reportActivity(`  ${module}: functional spec ${missing.join(", ")} is not built anywhere - nothing to regenerate again there`);
-            return statuses;
+                const missing = frids.filter((frid) => !found.has(frid));
+                if (found.size === 0)
+                    throw new Error(`${module} has no functional spec ${missing.join(", ")} built anywhere, so there is nothing to regenerate again: regenerate builds what is not built.`);
+                const statuses = await loop.bringUp(plainFile, request);
+                if (missing.length > 0)
+                    reportActivity(`  ${module}: functional spec ${missing.join(", ")} is not built anywhere - nothing to regenerate again there`);
+                return statuses;
+            });
         },
         drift(plainFile) {
             const file = resolve(options.cwd, plainFile);
@@ -1285,21 +1327,23 @@ export function createWorkLoop(options) {
             return loop.bringUp(plainFile, request);
         },
         async fromScratch(plainFile, { chain, ...request } = {}) {
-            const file = resolve(options.cwd, plainFile);
-            // Where its code lives: the tips its module is built in, or - none built yet - its own codebase. The whole chain:
-            // every codebase in those chains, bottom first - a tip taken back to nothing is otherwise started from a copy of
-            // the code below it.
-            const chains = chainsFor(file);
-            const codebases = [...new Map((chain === true ? chains.flat() : chains.map(tipOf)).map((entry) => [entry.buildDir, entry])).values()];
-            for (const entry of codebases) {
-                if (modules.get(entry.buildDir)?.running !== undefined)
-                    throw new Error(`${entry.moduleName} has a pulse running: halt it, or ask again once it is done.`);
-            }
-            const why = chain === true ? "asked to be regenerated from scratch, with its whole chain" : "asked to be regenerated from scratch";
-            for (const entry of codebases)
-                if (started(entry))
-                    startAgain(entry, why);
-            return loop.bringUp(plainFile, request);
+            return preparingFor(plainFile, async () => {
+                const file = resolve(options.cwd, plainFile);
+                // Where its code lives: the tips its module is built in, or - none built yet - its own codebase. The whole chain:
+                // every codebase in those chains, bottom first - a tip taken back to nothing is otherwise started from a copy of
+                // the code below it.
+                const chains = chainsFor(file);
+                const codebases = [...new Map((chain === true ? chains.flat() : chains.map(tipOf)).map((entry) => [entry.buildDir, entry])).values()];
+                for (const entry of codebases) {
+                    if (modules.get(entry.buildDir)?.running !== undefined)
+                        throw new Error(`${entry.moduleName} has a pulse running: halt it, or ask again once it is done.`);
+                }
+                const why = chain === true ? "asked to be regenerated from scratch, with its whole chain" : "asked to be regenerated from scratch";
+                for (const entry of codebases)
+                    if (started(entry))
+                        startAgain(entry, why);
+                return loop.bringUp(plainFile, request);
+            });
         },
         halt(target, reason) {
             const named = target.trim();
@@ -1346,62 +1390,81 @@ export function createWorkLoop(options) {
             ].join("");
         },
         status() {
-            return order.map((key) => statusOf(modules.get(key)));
+            return [...order.map((key) => statusOf(modules.get(key))), ...preparingAlone().map(({ since: _since, ...status }) => status)];
         },
         planned() {
             const now = Date.now();
             let sequence = Number.MAX_SAFE_INTEGER;
             // The last job - running or planned - of each module, by name: what a module waiting for it waits behind.
             const lastOf = new Map();
-            return order.flatMap((key) => {
-                const state = modules.get(key);
-                const tip = tipEntry(state);
-                const status = statusOf(state);
-                let before = status.running?.jobId;
-                if (before !== undefined)
-                    lastOf.set(tip.moduleName, before);
-                const row = (id, summary, note, waitingOn, conformance = false) => ({
-                    id,
-                    kind: conformance ? "conformance" : "regenerate",
-                    summary,
-                    module: tip.moduleName,
-                    note,
-                    ...(state.model !== undefined ? { model: state.model } : {}),
-                    status: "queued",
-                    sequence: sequence--,
-                    queuedAt: now,
-                    startedAt: now,
-                    waitingOn,
-                    tail: "",
-                    activity: [],
-                    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
-                    agents: [],
-                    transcript: [],
-                });
-                // Waiting for the module below it: not planned yet, but in the queue all the same - behind what it waits for.
-                if (state.running === undefined && state.waitsFor !== undefined) {
-                    const behind = lastOf.get(state.waitsFor);
-                    const id = `planned-${tip.moduleName}-waiting`;
-                    lastOf.set(tip.moduleName, id);
-                    return [
-                        row(id, `${basename(tip.plainFile)} - waits for ${state.waitsFor}`, `Not planned yet: its work is planned into pulses once ${state.waitsFor} is built - the code it is built on.`, behind !== undefined ? [behind] : []),
-                    ];
-                }
-                return status.planned.map((job, index) => {
-                    const planned = row(`planned-${tip.moduleName}-${index + 1}`, `${basename(tip.plainFile)} ${job.track === "conformance" ? "conformance: " : ""}${job.title}`, job.waitsFor !== undefined
-                        ? `Scheduled, not started: the conformance tests of ${job.title}, once ${waitsText(job.waitsFor)} built - the code record has to have them first.`
-                        : job.afterCode === true
-                            ? "Not planned yet: the module's conformance tests are planned into pulses once its code is built."
-                            : job.planning === true
-                                ? `Being planned into pulses now: ${job.title}. The first starts as soon as the plan is made.`
-                                : `Planned, not started: ${casesText(job.cases)}. It is planned again whenever the spec changes or a pulse before it ends.`, before !== undefined ? [before] : [], job.track === "conformance");
-                    if (job.planning === true)
-                        planned.planning = { since: state.planningSince ?? now };
-                    before = planned.id;
-                    lastOf.set(tip.moduleName, planned.id);
-                    return planned;
-                });
-            });
+            // A module asked for that the loop holds nothing of yet: being planned, from the moment it was asked for.
+            const early = preparingAlone().map(({ module: name, since }) => ({
+                id: `planned-${name}-preparing`,
+                kind: "regenerate",
+                summary: `${name}.plain - being planned`,
+                module: name,
+                note: "Being planned into pulses now. The first starts as soon as the plan is made.",
+                status: "queued",
+                sequence: sequence--,
+                queuedAt: since,
+                startedAt: since,
+                waitingOn: [],
+                tail: "",
+                activity: [],
+                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+                agents: [],
+                transcript: [],
+                planning: { since },
+            }));
+            return [...early, ...order.flatMap((key) => {
+                    const state = modules.get(key);
+                    const tip = tipEntry(state);
+                    const status = statusOf(state);
+                    let before = status.running?.jobId;
+                    if (before !== undefined)
+                        lastOf.set(tip.moduleName, before);
+                    const row = (id, summary, note, waitingOn, conformance = false) => ({
+                        id,
+                        kind: conformance ? "conformance" : "regenerate",
+                        summary,
+                        module: tip.moduleName,
+                        note,
+                        ...(state.model !== undefined ? { model: state.model } : {}),
+                        status: "queued",
+                        sequence: sequence--,
+                        queuedAt: now,
+                        startedAt: now,
+                        waitingOn,
+                        tail: "",
+                        activity: [],
+                        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+                        agents: [],
+                        transcript: [],
+                    });
+                    // Waiting for the module below it: not planned yet, but in the queue all the same - behind what it waits for.
+                    if (state.running === undefined && state.waitsFor !== undefined) {
+                        const behind = lastOf.get(state.waitsFor);
+                        const id = `planned-${tip.moduleName}-waiting`;
+                        lastOf.set(tip.moduleName, id);
+                        return [
+                            row(id, `${basename(tip.plainFile)} - waits for ${state.waitsFor}`, `Not planned yet: its work is planned into pulses once ${state.waitsFor} is built - the code it is built on.`, behind !== undefined ? [behind] : []),
+                        ];
+                    }
+                    return status.planned.map((job, index) => {
+                        const planned = row(`planned-${tip.moduleName}-${index + 1}`, `${basename(tip.plainFile)} ${job.track === "conformance" ? "conformance: " : ""}${job.title}`, job.waitsFor !== undefined
+                            ? `Scheduled, not started: the conformance tests of ${job.title}, once ${waitsText(job.waitsFor)} built - the code record has to have them first.`
+                            : job.afterCode === true
+                                ? "Not planned yet: the module's conformance tests are planned into pulses once its code is built."
+                                : job.planning === true
+                                    ? `Being planned into pulses now: ${job.title}. The first starts as soon as the plan is made.`
+                                    : `Planned, not started: ${casesText(job.cases)}. It is planned again whenever the spec changes or a pulse before it ends.`, before !== undefined ? [before] : [], job.track === "conformance");
+                        if (job.planning === true)
+                            planned.planning = { since: state.planningSince ?? preparing.get(tip.moduleName)?.since ?? now };
+                        before = planned.id;
+                        lastOf.set(tip.moduleName, planned.id);
+                        return planned;
+                    });
+                })];
         },
         firsts() {
             return order.flatMap((key) => {
@@ -1467,7 +1530,7 @@ export function createWorkLoop(options) {
     return loop;
 }
 /** Why nothing runs in a codebase whose code - and conformance tests, where they are wanted - is built from its spec as it is. */
-export const UP_TO_DATE = "built from the spec as it is";
+export const UP_TO_DATE = "built from the ***plain as it is";
 /** Why a codebase with work left has no plan: the planner found none. */
 const NO_PLAN = "the planner found no way to cut the work into pulses that hold together";
 /** A diff's lines placed in the .plain files of a chain - the tip's first - named as they are from the project. */
@@ -1570,13 +1633,13 @@ export function describeModules(statuses, options = {}) {
         .map((status) => {
         // Nothing to do there: said in a sentence, not as a status.
         if (isUpToDate(status))
-            return `${status.module} is up to date: its code is built from the spec as it is now in ${basename(status.plainFile)}, so there is nothing to regenerate.`;
+            return `${status.module} is up to date: its code is built from the ***plain as it is now in ${basename(status.plainFile)}, so there is nothing to regenerate.`;
         const lines = [`${status.module} (${basename(status.plainFile)}${status.stack !== undefined ? `, stack ${status.stack}` : ""}):`];
         if (status.running !== undefined) {
             lines.push(`  running: pulse ${status.running.jobId} - ${status.running.title}`);
             // Steered, not stopped or planned again: what changed went to its agent.
             for (const why of status.running.steered ?? [])
-                lines.push(`    ⇢ steered: ${why} - its agent was told, and it lands the spec as it is now there`);
+                lines.push(`    ⇢ steered: ${why} - its agent was told, and it lands the ***plain as it is now there`);
         }
         status.planned.forEach((job, index) => lines.push(job.afterCode === true
             ? `  ${index + 1}. conformance tests - planned once the code is built`

package/docs/regenerating.md

@@ -332,7 +332,7 @@ Either way the choice is made inside the pulse, so it is made - and its conforma
 
 **Scheduled ahead of the code.** `conform` may name functional specs whose code is not built yet: each call schedules them as one group, shown at once in what is planned, after the module's last code job. Its functional specs are chosen once the code record has every one as \*\*\*plain has it, and its tests are written once the module's code is built. A functional spec \*\*\*plain does not have - built by no code job - or a module with no test reqs is refused, and nothing is scheduled; one taken out of \*\*\*plain later is dropped from its group. Groups whose code is built by then are tested together, in one job with the rest, as far as the guardrail lets.
 
-While a codebase's work is being planned into jobs, with nothing running there, what is planned says so - the conformance tests of the groups being planned, or the work - rather than showing nothing until the plan is made.
+While a codebase's work is being planned into jobs, with nothing running there, what is planned says so - the conformance tests of the groups being planned, or the work - rather than showing nothing until the plan is made. A module asked for - `regenerate`, from scratch, functionalities again - shows its work as being planned from that moment, before its code is deleted and what is left is worked out, not only once the planner runs: in the loop's status, which a host draws its plan from, and in the job panel - a module the loop holds nothing of yet, as when turri was just opened, too. A \*\*\*plain change is looked at quietly.
 
 **What a conformance job tests is built.** As a conformance job starts, the harness reads the code record, `code/.turri.json`, and checks that it has every functional spec the job adds or changes tests for, as the job has it. One it does not have stops the job before any agent runs: its report says which are not built, the conformance tests halt, and the chat model tells the person. They are tried again once the code or \*\*\*plain changes. Code jobs and conformance jobs are planned apart, each track on its own: a job is one or the other. A module built on another starts with an empty tests record: the tests it inherits are the module below's, and none of its own is written yet.
 

package/docs/using.md

@@ -59,7 +59,7 @@ A pulse is one unit of work regenerating the code. It was called a job, and stil
 
 A regeneration takes minutes, so in the TUI every tool that regenerates starts the work as a pulse and returns straight away. The conversation carries on, and you need not wait for a pulse to finish: go on shaping the \*\*\*plain and writing its next change, ask questions, try what has landed - turri says so as each pulse starts, and never waits for one itself. A \*\*\*plain change made meanwhile steers the running pulse or is planned again around it (see below); pulses on the same module - or on modules of one `requires` chain - queue behind each other, in the order they were asked for, from the first pulse on: one queued while the module's \*\*\*plain is only a scaffold, with no functional specs yet, or while it does not parse, still holds its module, so nothing on the module runs beside it. Pulses on modules that share nothing run side by side, each with its own progress panel - two modules or ten. How many run at once is capped by what the machine has room for: past `parallel-jobs` (see [the project config](config.md#how-many-jobs-at-once)), a pulse whose turn has come waits for a free slot, and says so.
 
-- **The panel** above the input, while something runs, shows on top what finished - a line a module, the module that finished last on top, its pulses newest first, each with its mark (green, red or amber, as in the side panel), number and kind - what it regenerated is in the side panel - `cognio  ✓ 4 conformance · ✓ 3 regenerate · … 2 earlier`, the newest that fit the width - then a rule, and under it each running pulse, the newest first - `cognio · regenerate pulse 5`, `cognio · conformance pulse 6` - its time and cost, and what its agents are doing. A module whose work is being planned into pulses shows at once, before any pulse runs - `shorty · planning the pulses · 12s` - the planner is an agent, and takes a while; a `/regenerate` says it began the moment it is sent. Pulses are numbered within their module, as regen numbers them. `ctrl+o` expands the agents' trace alone; what finished stays a line a module. The line of keys under it - `ctrl+o to expand the trace · ctrl+h to peek at regen` - has each key breathing, fully there to a little faint and back, until it is first pressed: once `ctrl+o` has opened the trace, or the side panel has been opened, that key is still for the rest of the session and the other breathes on. What waits is not in it, and it shows no \*\*\*plain diff - the side panel has both. With nothing running it is gone.
+- **The panel** above the input, while something runs, shows on top what finished - a line a module, the module that finished last on top, its pulses newest first, each with its mark (green, red or amber, as in the side panel), number and kind - what it regenerated is in the side panel - `cognio  ✓ 4 conformance · ✓ 3 regenerate · … 2 earlier`, the newest that fit the width - then a rule, and under it each running pulse, the newest first - `cognio · regenerate pulse 5`, `cognio · conformance pulse 6` - its time and cost, and what its agents are doing. A module whose work is being planned into pulses shows at once, before any pulse runs - `shorty · planning the pulses · 12s` - from the moment it is asked for: while its code is deleted for a start from scratch and what is left to regenerate is worked out, as well as while the planner, an agent, cuts it into pulses; a `/regenerate` says it began the moment it is sent. A \*\*\*plain change is looked at quietly, and shows only once the planner runs. Pulses are numbered within their module, as regen numbers them. `ctrl+o` expands the agents' trace alone; what finished stays a line a module. The line of keys under it - `ctrl+o to expand the trace · ctrl+h to peek at regen` - has each key breathing, fully there to a little faint and back, until it is first pressed: once `ctrl+o` has opened the trace, or the side panel has been opened, that key is still for the rest of the session and the other breathes on. What waits is not in it, and it shows no \*\*\*plain diff - the side panel has both. With nothing running it is gone.
 - **A pulse's change** is what its agent works from, not a text diff of the module's file: the items `<spec change>` gives the agent - only what the pulse's functional specs use, an import's items as well as the module's own, a code pulse's without the test reqs - each in the file it is written in, under its section, in the file's order (`change-view.ts`).
 - **A \*\*\*plain diff**, in the side panel, reads as an editor shows a diff: its [\*\*\*plain](https://plainlang.org/docs/) highlighted as [plyn](https://github.com/plainlang/plyn) highlights it - section headers, concepts, names in backticks, text in quotes, links, the front matter - each added line filled green and each removed one red, the text on top, the fill the width of the panel ([colours](theming.md#plain-diffs)). It is shown file by file, each file's lines together under its name, with what it adds and takes out - the module being regenerated first, the rest by name, and none the diff does not change. Each line has its number in that file: a \*\*\*plain diff is of \*\*\*plain as read, with what it imports laid in, so a line is placed in the file it is written in - its links read as the parser renders them - and a removed line, in no file now, goes with the change it is part of and has no number. A line is never put in a file on a guess: one that cannot be placed is listed last, under "not found in the spec's files". Where lines of a file are not in the diff, `↕ 28 lines` says how many, as GitHub does - `↑` above the first - and names the section the lines under it are in when it is another than the one above, `↕ 28 lines · ***functional specs***`, as GitHub names a hunk's function: each section is named once.
 - **The side panel** (`ctrl+h`, as it was left - but on the pulse that last failed, stopped or did not pass, when one has since it was last opened: the live panel that showed it is gone with the last pulse, and its announcement in the chat says `ctrl+h shows this pulse`; **`/pulses`** on the pulses; not `ctrl+j`, which a terminal without the Kitty keyboard protocol sends as a line feed, the same as `shift+enter`, and which a dialog takes for `enter`; both stay [pi](https://pi.dev)'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 half of the screen, and `s` again over the whole screen. It opens as it was last left, for the conversation; a terminal under 104 columns - 100 inside the screen's padding, a blank row above and below everything and two columns either side - has no room for both and shows the panel over the whole screen. It opens on **regen**: the module's \*\*\*plain itself, in full, with how much of it the code has been regenerated from drawn onto it.
@@ -92,7 +92,7 @@ A regeneration takes minutes, so in the TUI every tool that regenerates starts t
 - **`/stack`** chooses the stack everything is built with from then on, in a project whose parts are on different stacks: a list of the project's stacks, or `/stack backend`, `/stack none`. The stack's `config.turri.<stack>.yaml` is laid over `config.turri.yaml` - its testing scripts, toolchains, models - for the session; a module already asked for keeps the stack it was asked for with. The chat model switches it too when you ask - and, to build one part, passes that part's stack to `regenerate` instead, leaving the session's as it is. See [stacks](config.md#stacks).
 - **`/regenerate [module | file.plain] [functionality ...] [from scratch [whole chain]] [how to cut the work]`** regenerates a module from its \*\*\*plain as it is now, as the `regenerate` tool does: what is left to regenerate is planned into pulses - one functional spec at a time, a few together or the whole module in one, as the planner judges - and the first starts. Words after the module are guidance for that plan (`/regenerate app models first`). A module's name typed with spaces for its underscores is that module - `/regenerate d365_function executor` is `d365_function_executor`. With no module named: the one `module:` in `config.turri.yaml` names, else the folder's top modules, to pick from. Asked for from scratch - `from scratch`, `start over`, `delete the module` - it asks first, then deletes the module's code and conformance tests in every codebase where they live, committed so `/lineage` keeps them, and regenerates the whole module from its \*\*\*plain, built though nothing in it changed: `/regenerate shorty from scratch`. The modules below it keep their code, and the module starts again from a copy of the code below it. Asked for its chain too - `/regenerate shorty from scratch, the whole chain` - the code of every module of its requires chain is deleted, the base's included, and the whole chain is regenerated from the bottom: what to do after modules were split, merged or moved, when the code below was laid out for modules that are no more. The chat's `regenerate` does the same with `from_scratch: "module"` or `"chain"`, when you ask for it; `turri regenerate --from-scratch` or `--from-scratch-chain` on the command line, not with `--dry-run`. Functionalities named after the module - `/regenerate shorty 3 5` - are regenerated though their \*\*\*plain did not change, on the model chosen for functionalities: as `turri regenerate shorty.plain 3 5` does, and the chat's `regenerate` with `functionalities`.
 - **`/halt <id>`** halts a pulse - a queued one never starts - **`/halt <module>`** (or a planned row's id) halts a module's planned pulses until you ask for it again, a \*\*\*plain change not starting it, and **`/halt activated <name>`** halts a server `activate` started; it lists all three when no id is given.
-- **What these commands show you, the chat knows.** What `/regenerate` and `/halt activated` tell you - \*\*\*plain that does not parse, the pulses planned, a server halted - stays in the chat under the command, and since a slash command runs outside the conversation, it is put in the conversation as well: say "fix it" next and turri knows what you are looking at. A halted pulse reaches it as every pulse's end does.
+- **What these commands show you, the chat knows.** What `/regenerate` and `/halt activated` tell you - \*\*\*plain that does not parse, the pulses planned, a server halted - stays in the chat under the command, and since a slash command runs outside the conversation, it is put in the conversation as well: say "fix it" next and turri knows what you are looking at. Once `/regenerate` has started pulses, turri says so in the chat too - what runs and what is planned, and that you need not wait for it - without starting anything more for it; a module already up to date gets the plan's answer alone. A halted pulse reaches it as every pulse's end does.
 - **Nothing is queued.** What is left to build is worked out from what each codebase is built from and \*\*\*plain as it is now - again whenever a pulse ends or \*\*\*plain changes - and the first pulse of it runs; see [a whole module](regenerating.md#a-whole-module). Changes that overlap never pile up: the next pulse builds \*\*\*plain as it is. The pulses planned after the one running are listed behind it, as queued, and so is each module waiting for the one it is built on - "waits for base" - until it can be planned. A change inside what the running pulse regenerates - a functional spec it regenerates reworded or given a sub-bullet, a definition or req it is given, a file they link - steers it: its agent is told, and it lands \*\*\*plain as it is now there, twice a pulse at most. Otherwise a pulse building something \*\*\*plain no longer wants is stopped and rolled back - unless `allow-to-stop-jobs: false` in `config.turri.yaml`, which has it land first and the change regenerated on top. To drop something, take it out of \*\*\*plain - one \*\*\*plain diff. Stopping a pulse leaves its change in \*\*\*plain: the codebase waits until its \*\*\*plain changes or it is asked for again.
 - **A change to a module below** is made in the codebase at the tip of the chain, where its code lives; the codebase below is left as it was, and is brought up to its own \*\*\*plain only when a new module is to start from it. \*\*\*plain moved into a module the code was not built on stops the codebase: no change to its code brings that module in, so it has to be started over - its code and conformance tests taken out, kept in its history, and built again from the bottom of the chain. That is never done unasked: the chat asks you, saying why, and regenerates it from scratch once you agree; on the command line `turri regenerate` asks at the terminal, and `--start-over` agrees in advance.
 - **Conformance tests are a track of their own.** A code pulse lands once its unit tests pass and are reviewed. Then, before the next one builds on it, a conformance pulse writes and runs the tests of what it built - from the test reqs and acceptance tests - with the whole suite the module inherits, and, where one fails, fixes the test or the code, whichever is wrong; what they are written for is recorded in `tests/.turri.json`. With `conformance-tests: false` none is written until you ask - `conform`, for a module or some of its functional specs. A conformance pulse that does not pass is undone whole and halts the conformance tests alone: the code goes on being built.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.23",
+  "version": "0.1.24-next.2b2f203",
   "license": "MIT",
   "type": "module",
   "repository": {