@turri-dev/cli 0.1.7 → 0.1.8-next.e553476

package/README.md

@@ -49,7 +49,7 @@ turri init-config --vendor anthropic
 
 It then tells you which API key to set - or to type `/login` once **turri** is running instead. **turri** loads the `config.turri.yaml` in the folder you start it from. Below the two models, the file sets every other setting to its default - change any of them in the file, or from the chat with `/turri-config`. Any other model works too: [models](#models).
 
-Once `turri` is running, say: *Let's start a new project: a small API where people can register and sign in.*
+Once `turri` is running, type: `/spawn a small API where people can register and sign in` - or `/brood` for an interview that settles each feature with you first.
 
 No project of your own yet? Build one of [**the examples**](examples/README.md) with turri, step by step.
 
@@ -146,11 +146,11 @@ cd ~/my-project
 turri
 ```
 
-Then talk to it:
+Then start the interview:
 
-> Let's start a new project: a small API where people can register and sign in.
+> /brood a small API where people can register and sign in
 
-It runs the interview skill, asks you about the problem, the stack and the product, writes \*\*\*plain, and builds each functionality as it is written. While it works:
+It asks you about the problem, the stack and the product, writes \*\*\*plain, and builds each functionality as it is written. While it works:
 
 - the **panel** above the input shows every build - its stage, what its agents are doing, its model and cost - and the queue behind it;
 - ask to try it at any time - "let me try it" - and **`release`** puts what is built so far in `dist/<module>` and **`activate`** starts it, installing what it needs - nothing to approve;
@@ -188,7 +188,7 @@ Start at the [documentation index](docs/README.md), or go straight to a page:
 | | |
 | --- | --- |
 | [Installation](docs/installation.md) | doctor, what turri needs of this machine, **turri** and `pi`, environment variables |
-| [Examples](examples/README.md) | projects to build with turri step by step: cognio from an empty folder, guestbook - a backend and a frontend in minutes - a CLI, a backend service with conformance tests, a REST API integration |
+| [Examples](examples/README.md) | projects to build with turri step by step: guestbook - a backend and a frontend in minutes - a CLI, and a backend service with conformance tests |
 | [Using **turri**](docs/using.md) | the conversation, skills, tools, pulses and regen, choosing models, the command line |
 | [The project config](docs/config.md) | `config.turri.yaml` and each stack's `config.turri.<stack>.yaml`: every key, models and their inheritance, conformance, the testing scripts, stacks and choosing one, the old `config.yaml` |
 | [Deploy](docs/deploy.md) | trying what is built: the last commit in `dist/<module>`, started on your machine, nothing installed without asking |

package/dist/btw.d.ts

@@ -53,6 +53,8 @@ export interface SideQuestion {
     projectDir: string;
     /** turri's own folder: its source, skills, rules and docs. */
     harnessDir: string;
+    /** A host's surface, in its own words (TurriHost.surface): where the person watches the work instead of the terminal. */
+    surface?: string;
 }
 export declare function sideQuestionPrompt(side: SideQuestion): string;
 /** Answers a side question with an agent of its own, read only, on `model`. */

package/dist/btw.js

@@ -12,7 +12,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { confinedTools } from "./regenerate/confine.js";
-import { TURRI_IDENTITY } from "./identity.js";
+import { conversationIdentity } from "./identity.js";
 import { ask, BEGIN, createExecutor } from "./pi.js";
 /** How many tool calls the side agent may make before it is told to answer. */
 export const SIDE_CALLS = 20;
@@ -85,7 +85,7 @@ export function skillSessionText(runDir, maxChars = SKILL_SESSION_CHARS) {
 }
 export function sideQuestionPrompt(side) {
     return [
-        TURRI_IDENTITY,
+        conversationIdentity(side.surface),
         "",
         "The person is in the middle of something with you - a skill, a pulse - and has asked you a question on the side",
         "with /btw. Answer it as turri: in the first person, to them, in whole sentences - briefly and plainly, from what is",

package/dist/extension.d.ts

@@ -41,6 +41,17 @@ export interface TurriHost {
     onPlanChange?(): void;
     /** The dialogs ask_user puts its questions in - the conversation's and a skill's interview - instead of the terminal's. */
     dialogs?: AskUserIO;
+    /**
+     * The host's own UI, in its own words: the views it has in place of the terminal's, what its marks and buttons mean,
+     * where questions appear. Given, turri tells the model none of the terminal's - its keys, the side panel, regen,
+     * /pulses - and gives it this instead, as a `<surface>` block in turri's identity. Absent, the terminal is the surface.
+     */
+    surface?: string;
+    /**
+     * The last word on the whole system prompt, as turri has built it for this turn - after its own before_agent_start
+     * work: what it returns is what is sent. For a host that needs to change anything else.
+     */
+    systemPrompt?(prompt: string): string;
 }
 /** turri's conversation as an extension of pi's, for a host that runs it itself: see TurriHost. */
 export declare function createTurriExtension(host?: TurriHost): (pi: ExtensionAPI) => void;

package/dist/extension.js

@@ -53,13 +53,14 @@ import { describeStdlib } from "./stdlib.js";
 import { peekKeyListener, runAsk } from "./ask.js";
 import { QuestionDialog } from "./question-dialog.js";
 import { registerStacks } from "./stacks.js";
-import { catalogueLine, discoverSkills, leftOutNote } from "./skills.js";
+import { catalogueLine, createCommandGate, discoverSkills, leftOutNote, startedByCommandOnly } from "./skills.js";
 import { supersededByTurri } from "./chat-skills.js";
-import { TURRI_IDENTITY } from "./identity.js";
+import { conversationIdentity } from "./identity.js";
+import { setSurface, surfaceOf } from "./surface.js";
 import { turriIdentity } from "./environment.js";
 import { conformanceChooser } from "./regenerate/choose-conformance.js";
 import { answerSideQuestion, askWithAsides, BTW_HOW, runningSkill, skillRunStarted, skillSessionText, transcriptOf } from "./btw.js";
-import { createJobRegistry, defaultParallelJobs, describeJob, formatDuration, pulseName, shouldWait, STOPPED_ON_REQUEST, } from "./regenerate/jobs.js";
+import { createJobRegistry, defaultParallelJobs, describeJob, firstRegeneration, formatDuration, formatElapsed, pulseName, shouldWait, STOPPED_ON_REQUEST, } from "./regenerate/jobs.js";
 /**
  * Makes gated skills reachable from a conversation.
  *
@@ -180,6 +181,14 @@ export function chatAskUserTool(dialogs) {
         },
     };
 }
+/**
+ * The conversation's system prompt for a turn: pi's, turri's identity - with the host's surface in place of the
+ * terminal's, when it has one - and turri's blocks; then the host's last word on it.
+ */
+function conversationSystemPrompt(base, host, blocks) {
+    const prompt = [base, conversationIdentity(host.surface), ...blocks].filter((part) => part !== "").join("\n\n");
+    return host.systemPrompt !== undefined ? host.systemPrompt(prompt) : prompt;
+}
 /** The host each conversation's jobs report to, for the work loop made for them later. */
 const hosts = new WeakMap();
 /** turri's conversation as an extension of pi's, for a host that runs it itself: see TurriHost. */
@@ -260,6 +269,8 @@ function turriExtension(pi, host) {
         },
     });
     hosts.set(jobs, host);
+    // What the model is told of where the person watches the work, deep in the tools too: the host's surface, or the terminal.
+    setSurface(jobs, host.surface);
     host.onJobs?.(jobs);
     // The ***plain rules go into the system prompt in full, every turn. The block is
     // identical each time, so it sits inside the cached prefix rather than invalidating it.
@@ -298,7 +309,7 @@ function turriExtension(pi, host) {
             }
         }
         return {
-            systemPrompt: [event.systemPrompt, TURRI_IDENTITY, TOOLS_NOT_CLI, projectConfigBlock(cwd), machineBlock(cwd, machine.now()), rulesBlock()].filter((part) => part !== "").join("\n\n"),
+            systemPrompt: conversationSystemPrompt(event.systemPrompt, host, [TOOLS_NOT_CLI, projectConfigBlock(cwd), machineBlock(cwd, machine.now()), rulesBlock()]),
         };
     });
     // The conversation's agent does not run turri again through its shell, unless the person
@@ -314,7 +325,7 @@ function turriExtension(pi, host) {
         if (event.toolName === "bash" && typeof command === "string") {
             const what = selfInvocation(command);
             if (what !== undefined && !askedForCommandLine(lastUserMessage))
-                return { block: true, reason: refusal(what) };
+                return { block: true, reason: refusal(what, surfaceOf(jobs)) };
         }
         markConversationWrite(event.toolCallId, event.toolName, event.input);
         return undefined;
@@ -416,6 +427,19 @@ function turriExtension(pi, host) {
         return;
     const catalogue = skills.map(catalogueLine).join("\n");
     const pendingNote = leftOutNote(discoveredSkills);
+    // The skills the person starts themselves - brood, spawn, bud: each has its command, and cultivate starts it only
+    // once its command is typed. The command puts what was typed in the chat, as the person's message, for the model to
+    // run it with what follows as its context.
+    const gate = createCommandGate();
+    for (const skill of skills.filter((s) => s.commandOnly)) {
+        pi.registerCommand(skill.name, {
+            description: `Start ${skill.name}${skill.steps.length > 1 ? ` - ${skill.steps.map((step) => step.name).join(" → ")}` : ""}: /${skill.name} [what you want]`,
+            handler: async (args) => {
+                gate.typed(skill.name);
+                pi.sendUserMessage(`/${skill.name}${args.trim() !== "" ? ` ${args.trim()}` : ""}`, { deliverAs: "followUp" });
+            },
+        });
+    }
     pi.registerTool({
         name: "cultivate",
         label: "Cultivate",
@@ -426,6 +450,7 @@ function turriExtension(pi, host) {
         promptSnippet: "cultivate: run a gated skill - its steps and review gates enforced by turri",
         promptGuidelines: [
             "When a request matches a skill listed in cultivate's description, call cultivate instead of doing the work yourself. Doing it by hand skips the review gates.",
+            "A skill marked as started only by the person runs only from its command: a message that is its command - /spawn a small server - is the person starting it, so call cultivate for it at once, with what follows the command as context. Never call cultivate for one otherwise; tell them to type its command.",
             // pi lists .agents/skills among its own skills too: read and followed by hand, a skill's gates would be skipped.
             "A skill cultivate lists may also be among your own skills, from the project's .agents/skills: run it with cultivate all the same, never by reading its SKILL.md and following it.",
             "cultivate returns the reviewed artifact and a trace of every gate decision. Report the artifact to the user; do not rewrite it.",
@@ -458,6 +483,8 @@ function turriExtension(pi, host) {
                     details: {},
                 };
             }
+            if (!gate.mayStart(skill))
+                return { content: [{ type: "text", text: startedByCommandOnly(skill.name) }], details: { notStarted: true } };
             // A new run clears the run folder. An interrupted one is not thrown away by accident:
             // whether to pick it up or start over is the user's call.
             const runDir = skillRunDir(cwd, skill.name);
@@ -475,6 +502,8 @@ function turriExtension(pi, host) {
                     details: { interrupted },
                 };
             }
+            // Its command is used up: started again later, it is typed again.
+            gate.started(skill.name);
             const trace = [`skill: ${skill.name}`, ...describeGates(skill).map((l) => `  ${l}`)];
             // While it runs, what its agent is doing leads: pi shows a running tool's first lines, and the trace's first
             // lines are the gates, which say nothing about now. The result keeps the trace alone.
@@ -560,6 +589,8 @@ function turriExtension(pi, host) {
             const filesBefore = projectFiles(cwd);
             // A side question asked while it runs is told what it has done so far.
             const ended = skillRunStarted({ skill: skill.name, dir: skill.dir, step: () => live.step, trace: () => [...trace], runDir });
+            // From here the time to first regeneration is counted, for a skill that writes spec diffs: its first pulse started.
+            const began = Date.now();
             const { result, output: captured } = await captureConsole(() => runSkill({
                 skillDir: skill.dir,
                 cwd,
@@ -620,11 +651,17 @@ function turriExtension(pi, host) {
                 ? `${specsChanged.join(", ")} changed, and nothing is regenerated from that yet: call regenerate for it, and the code is brought up to the spec.`
                 : "";
             const gated = skill.steps.some((step) => step.gate !== undefined);
+            const first = skill.allowedTools.includes("write_spec_diff") ? firstRegeneration(jobs.list(), began) : {};
+            const ttfr = first.started === undefined
+                ? ""
+                : `Time to first regeneration: ${formatElapsed(first.started)} - its first pulse started that long after ${skill.name} began` +
+                    (first.landed !== undefined ? `, and landed after ${formatElapsed(first.landed)}.` : ".");
             const text = result.ok
                 ? [
                     gated ? `${skill.name}: passed all gates.` : `${skill.name}: finished. It has no review gates, so nothing checked its work: read what it changed before you report it.`,
                     changed,
                     ...(unrendered !== "" ? [unrendered] : []),
+                    ...(ttfr !== "" ? [ttfr] : []),
                     "",
                     "<artifact>",
                     result.output,
@@ -2083,6 +2120,7 @@ async function askOnTheSide(pi, ctx, cwd, jobs, question) {
         pulses: jobs.list().map((job) => `${job.id} ${job.status}: ${pulseName(job)}`),
         projectDir: cwd,
         harnessDir: PACKAGE_ROOT,
+        ...(surfaceOf(jobs) !== undefined ? { surface: surfaceOf(jobs) } : {}),
     }, chatModelOf(ctx));
     try {
         pi.appendEntry(SIDE_ENTRY, { question, answer });

package/dist/identity.d.ts

@@ -1,2 +1,7 @@
-/** Who the conversation's agent is: turri, and what it does - first, so it speaks as turri, in the first person. */
+/**
+ * Who the conversation's agent is: turri, and what it does - first, so it speaks as turri, in the first person. Where
+ * the person watches the work is the terminal's regen; given a host's surface, that is said in its place.
+ */
+export declare function conversationIdentity(surface?: string): string;
+/** turri as the terminal runs it. */
 export declare const TURRI_IDENTITY: string;

package/dist/identity.js

@@ -1,5 +1,31 @@
-/** Who the conversation's agent is: turri, and what it does - first, so it speaks as turri, in the first person. */
-export const TURRI_IDENTITY = [
+/** In the terminal: regen, where the person watches the work - the side panel, its key, and the pulses behind it. */
+const REGEN = [
+    "- regen is the side panel (ctrl+h): the spec with each functionality and item marked built, regenerating,",
+    "  planned or waiting - and behind it the pulses (/pulses), every pulse regenerating, planned and finished. Say regen,",
+    "  lowercase. It was the regeneration, the job queue, or the job panel.",
+];
+/** In a host: where the person watches the work is the host's to say - its surface, below. */
+const HOST_SURFACE = [
+    "- What the person sees of your work - where they watch it, and what they press - is the app's you run in, and",
+    "  <surface> below says it in its own words. Say only what it says, and speak of no key, panel or view it does not",
+    "  name.",
+];
+/**
+ * Who the conversation's agent is: turri, and what it does - first, so it speaks as turri, in the first person. Where
+ * the person watches the work is the terminal's regen; given a host's surface, that is said in its place.
+ */
+export function conversationIdentity(surface) {
+    const text = surface?.trim() ?? "";
+    const hosted = text !== "";
+    return [
+        ...IDENTITY_BEFORE,
+        ...(hosted ? HOST_SURFACE : REGEN),
+        ...IDENTITY_AFTER,
+        ...(hosted ? ["", "<surface>", text, "</surface>"] : []),
+        "</turri>",
+    ].join("\n");
+}
+const IDENTITY_BEFORE = [
     "<turri>",
     "You are turri - always lowercase - a coding agent with the power of regenerative software. The software is its",
     "***plain; the code is regenerated from it. You help the person write ***plain, and you regenerate the code from it a",
@@ -25,11 +51,11 @@ export const TURRI_IDENTITY = [
     "- A pulse is one unit of work regenerating the code - a spec diff regenerated in a codebase, or its conformance",
     "  tests. It was called a job, and still is in places: the job_id a tool takes is a pulse's id, and parallel-jobs and",
     "  allow-to-stop-jobs in config.turri.yaml are about pulses. \"Job\" in what you read is a pulse; say pulse.",
-    "- regen is the side panel (ctrl+h): the spec with each functionality and item marked built, regenerating,",
-    "  planned or waiting - and behind it the pulses (/pulses), every pulse regenerating, planned and finished. Say regen,",
-    "  lowercase. It was the regeneration, the job queue, or the job panel.",
+];
+const IDENTITY_AFTER = [
     "- mutate, in a skill's activity, is write_spec_diff: a spec change written and regenerated in one step.",
     "- Regenerate is the word for what you do to the code: never grow, grew or grown - older text, a tool's description",
     "  or a report may still say it, and means regenerate.",
-    "</turri>",
-].join("\n");
+];
+/** turri as the terminal runs it. */
+export const TURRI_IDENTITY = conversationIdentity();

package/dist/loop-tools.js

@@ -9,6 +9,7 @@ import { pulseName } from "./regenerate/jobs.js";
 import { stopDeployed } from "./regenerate/release.js";
 import { projectDirOf } from "./regenerate/paths.js";
 import { findTestScripts } from "./regenerate/test-scripts.js";
+import { surfaceOf } from "./surface.js";
 /** How the queue is to be planned, for the work this call queues - see regenerate/steer.ts. */
 export const GUIDANCE_PARAM = Type.Optional(Type.String({
     description: "How to plan the queue for this work, in a sentence or two - which functional specs go together, what first - as " +
@@ -114,8 +115,9 @@ export function stopJob(jobs, named, reason, loop) {
     if (module !== undefined)
         return module;
     const matches = jobs.list().filter((job) => job.id.startsWith(named.trim()));
+    // /pulses is the terminal's: in a host, the pulses tool lists them.
     if (matches.length === 0)
-        return `No pulse ${named}. /pulses shows them.`;
+        return `No pulse ${named}. ${surfaceOf(jobs) !== undefined ? "The pulses tool lists them." : "/pulses shows them."}`;
     if (matches.length > 1)
         return `'${named}' matches ${matches.map((job) => job.id).join(", ")}. Give more of the id.`;
     const target = matches[0];

package/dist/regenerate/cases.js

@@ -64,6 +64,9 @@ export function conformanceCasesBlock(cases) {
     if (cases.patch.length > 0) {
         lines.push(`- Changed - its text, its acceptance tests, or a concept it uses: ${named(cases.patch)}.`, "  Its conformance tests exist: rewrite them to what it says now. The tests of everything else stay as they are.");
     }
+    if (cases.again.length > 0) {
+        lines.push(`- Regenerated again - its code was built anew, and its conformance tests were written against the code it replaced: ${named(cases.again)}.`, "  Its text did not change, but the code did. Run its tests against the new code. What they check that the", "  specification says stays checked: rewrite such a test only as the new code needs it reached. What they check", "  that the specification leaves open - a path, a field, a message, a format the old code chose and the", "  specification never names - is the new code's choice now: rewrite those checks to what the new code does,", "  or take them out. No test may hold the new code to what only the old code did. The tests of everything else", "  stay as they are.");
+    }
     if (cases.delete.length > 0)
         lines.push(`- Taken out - remove its conformance tests: ${named(cases.delete)}.`);
     if (cases.mechanical) {

package/dist/regenerate/jobs.d.ts

@@ -163,6 +163,15 @@ export declare function createJobRegistry(options?: {
 export declare function formatDuration(job: Job): string;
 /** "42s", "3m 12s", "1h 5m": how long something has run. */
 export declare function formatElapsed(ms: number): string;
+/**
+ * How soon after `since` the first code pulse queued since then started - the time to first regeneration - and how soon
+ * the first of them landed, when one has: from then on there is something to try. In milliseconds; either is undefined
+ * until it has happened.
+ */
+export declare function firstRegeneration(jobs: Job[], since: number): {
+    started?: number;
+    landed?: number;
+};
 /**
  * What a pulse is called wherever it is shown in a line: its module, kind and number - `shorty · regenerate pulse 3`,
  * `shorty · conformance pulse 6` - never what it regenerates, which is the agents' words and long. A job of no module,

package/dist/regenerate/jobs.js

@@ -377,6 +377,17 @@ export function formatElapsed(ms) {
         return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
     return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
 }
+/**
+ * How soon after `since` the first code pulse queued since then started - the time to first regeneration - and how soon
+ * the first of them landed, when one has: from then on there is something to try. In milliseconds; either is undefined
+ * until it has happened.
+ */
+export function firstRegeneration(jobs, since) {
+    const pulses = jobs.filter((job) => job.kind === "regenerate" && job.queuedAt >= since && job.status !== "queued");
+    const started = Math.min(...pulses.map((job) => job.startedAt));
+    const landed = Math.min(...pulses.filter((job) => job.status === "succeeded" && job.details?.landed === true && job.finishedAt !== undefined).map((job) => job.finishedAt));
+    return { ...(Number.isFinite(started) ? { started: started - since } : {}), ...(Number.isFinite(landed) ? { landed: landed - since } : {}) };
+}
 /**
  * What a pulse is called wherever it is shown in a line: its module, kind and number - `shorty · regenerate pulse 3`,
  * `shorty · conformance pulse 6` - never what it regenerates, which is the agents' words and long. A job of no module,

package/dist/regenerate/loop.d.ts

@@ -385,6 +385,12 @@ export declare function isUpToDate(status: ModuleStatus): boolean;
 export declare function describeModules(statuses: ModuleStatus[], options?: {
     for?: "chat" | "command line";
 }): string;
+/**
+ * A module's first pulse when it builds one functional spec - the project set up and the smallest thing that runs: it lands on its
+ * unit tests alone, with no review. A reviewer, and an arbiter after it, on a scaffold is time spent before anything can
+ * be tried.
+ */
+export declare function skipsReview(cases: JobCases): boolean;
 /** How a code pulse went, for its line in the notes: the rounds it took, its test runs, what the debugger found. */
 export declare function codeStory(result: {
     attempts?: number;

package/dist/regenerate/loop.js

@@ -9,7 +9,7 @@ import { commitNotes, recordHistory, resetToLastCommit } from "./lineage.js";
 import { NOTES_FILE, recordPulse } from "./notes.js";
 import { createJobRegistry, formatDuration } from "./jobs.js";
 import { moduleLanes } from "./lanes.js";
-import { adoptDigests, chainTree, codeTree, conformanceTarget, REGENERATE_AGAIN, inheritedRecord, notBuilt, readRecord, RECORD_FILE, withResourceDigests, writeCodeRecord, writeTestsRecord, } from "./records.js";
+import { adoptDigests, chainTree, codeTree, conformanceTarget, marksRegenerateAgain, REGENERATE_AGAIN, inheritedRecord, notBuilt, readRecord, RECORD_FILE, withResourceDigests, writeCodeRecord, writeTestsRecord, } from "./records.js";
 import { describeSpecDiffConformance, renderSpecDiffConformance } from "./conform.js";
 import { conformanceDirFor } from "./conformance.js";
 import { modulesRoot } from "./paths.js";
@@ -153,7 +153,8 @@ export function functionalityCompletion(plainFile) {
         codebase.forEach((entry, index) => {
             const count = counts[index];
             const completed = entry.frids.filter((frid) => !touched.has(`${entry.moduleName}:${frid}`));
-            const tested = (readRecord(conformanceDirFor(entry.moduleName, modulesRoot(projectDirOf(entry.plainFile))))?.[FUNCTIONAL_REQUIREMENTS] ?? []).filter((item) => item.frid !== undefined && item.markdown.trim() === specText(entry.moduleName, item.frid));
+            // Tests marked to regenerate again were written against code since replaced: not conformance tested until rewritten.
+            const tested = (readRecord(conformanceDirFor(entry.moduleName, modulesRoot(projectDirOf(entry.plainFile))))?.[FUNCTIONAL_REQUIREMENTS] ?? []).filter((item) => item.frid !== undefined && !marksRegenerateAgain(item) && item.markdown.trim() === specText(entry.moduleName, item.frid));
             count.completed = completed.length;
             count.tested = completed.filter((frid) => tested.some((item) => item.frid === frid));
             count.conformanceTested = count.tested.length;
@@ -521,7 +522,7 @@ export function createWorkLoop(options) {
             run: async (onDelta) => {
                 // The guardrail: a conformance job tests only code that is built - the code record, read as the job starts, has every functional spec it tests as it tests it.
                 if (conformance) {
-                    const testing = [...planned.cases.add, ...planned.cases.patch].map((touched) => touched.frid);
+                    const testing = [...planned.cases.add, ...planned.cases.patch, ...planned.cases.again].map((touched) => touched.frid);
                     const missing = notBuilt(readRecord(tip.buildDir), planned.step.tree, testing);
                     if (missing.length > 0) {
                         const record = relative(options.cwd, join(tip.buildDir, RECORD_FILE));
@@ -1109,6 +1110,17 @@ export function createWorkLoop(options) {
                     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`);
             }
             const missing = frids.filter((frid) => !found.has(frid));
@@ -1600,6 +1612,14 @@ const defaultConformanceRunner = async (job, onDelta) => {
     }
     return { landed: result.passed, report: describeSpecDiffConformance(result), ...(result.specGaps !== undefined ? { specGaps: result.specGaps } : {}) };
 };
+/**
+ * A module's first pulse when it builds one functional spec - the project set up and the smallest thing that runs: it lands on its
+ * unit tests alone, with no review. A reviewer, and an arbiter after it, on a scaffold is time spent before anything can
+ * be tried.
+ */
+export function skipsReview(cases) {
+    return cases.fresh && cases.add.length <= 1 && cases.patch.length === 0 && cases.again.length === 0 && cases.delete.length === 0;
+}
 /** A job as a spec diff render, landed on its unit tests: conformance is a track of its own. */
 const defaultRunner = async (job, onDelta) => {
     const result = await renderSpecDiff({
@@ -1609,6 +1629,7 @@ const defaultRunner = async (job, onDelta) => {
         applied: "already applied",
         spec: job.spec,
         cases: job.planned.cases,
+        ...(skipsReview(job.planned.cases) ? { unitReview: false } : {}),
         ...(job.model !== undefined ? { model: job.model } : {}),
         ...(job.steering !== undefined ? { steering: job.steering } : {}),
         onDelta,

package/dist/regenerate/records.d.ts

@@ -63,9 +63,11 @@ export type Chosen = (frid: string) => boolean;
  * definitions and implementation reqs, with the test reqs as the spec has them now.
  *
  * Conformance follows the code, never goes ahead of it: a functional spec whose code is not caught up
- * with the spec - its text in the code record is not the spec's, or the code record does not have it at
- * all, as while it is regenerated again - stays as the tests record has it, until the code lands. Its tests are
- * taken out only once the spec and the code have both dropped it.
+ * with the spec - its text in the code record is not the spec's, the code record does not have it at
+ * all, or has it marked to regenerate again - stays as the tests record has it, until the code lands. Its tests are
+ * taken out only once the spec and the code have both dropped it. Tests marked to regenerate again with their code
+ * (`regenerateAgain`) differ from the target once the code lands: written against the code it replaced, they are
+ * conformance work again, though the spec's text never changed.
  */
 export declare function conformanceTarget(code: MarshalledPlainSource | null, tests: MarshalledPlainSource | null, spec: MarshalledPlainSource, chosen?: Chosen): MarshalledPlainSource;
 /**

package/dist/regenerate/records.js

@@ -155,9 +155,11 @@ export function inheritedRecord(source, sourceModule) {
  * definitions and implementation reqs, with the test reqs as the spec has them now.
  *
  * Conformance follows the code, never goes ahead of it: a functional spec whose code is not caught up
- * with the spec - its text in the code record is not the spec's, or the code record does not have it at
- * all, as while it is regenerated again - stays as the tests record has it, until the code lands. Its tests are
- * taken out only once the spec and the code have both dropped it.
+ * with the spec - its text in the code record is not the spec's, the code record does not have it at
+ * all, or has it marked to regenerate again - stays as the tests record has it, until the code lands. Its tests are
+ * taken out only once the spec and the code have both dropped it. Tests marked to regenerate again with their code
+ * (`regenerateAgain`) differ from the target once the code lands: written against the code it replaced, they are
+ * conformance work again, though the spec's text never changed.
  */
 export function conformanceTarget(code, tests, spec, chosen = () => true) {
     const built = itemsOf(code, FUNCTIONAL_REQUIREMENTS);
@@ -168,7 +170,7 @@ export function conformanceTarget(code, tests, spec, chosen = () => true) {
     for (let index = 0; index < Math.max(built.length, now.length); index += 1) {
         const frid = String(index + 1);
         const current = now[index];
-        if (current !== undefined && built[index]?.markdown.trim() === current.markdown.trim()) {
+        if (current !== undefined && built[index]?.markdown.trim() === current.markdown.trim() && !marksRegenerateAgain(built[index])) {
             if (chosen(frid))
                 specs.push({ ...current, frid });
             continue;

package/dist/regenerate/spec-map.js

@@ -8,7 +8,7 @@ import { conformanceDirFor } from "./conformance.js";
 import { chainSpec } from "./loop.js";
 import { modulesRoot, projectDirOf } from "./paths.js";
 import { HISTORY_DIR } from "./lineage.js";
-import { codeTree, readRecord, RECORD_FILE } from "./records.js";
+import { codeTree, marksRegenerateAgain, readRecord, RECORD_FILE } from "./records.js";
 import { specFilesOf } from "./regenerate.js";
 import { builtTips, resolveRequiresChain } from "./requires.js";
 import { changesBetween, layoutOf, serializeTree } from "./spec-steps.js";
@@ -115,17 +115,20 @@ export function pageItems(input) {
         }
     }
     // Conformance tests: of the functional specs, those the tests record has as they read now, as they read before, or taken out.
-    const tested = new Set(itemsOf(input.tested ?? null, FUNCTIONAL_REQUIREMENTS).map((item) => item.markdown.trim()));
+    // Tests marked to regenerate again were written against code since replaced: written for an earlier build, not now.
+    const testedItems = itemsOf(input.tested ?? null, FUNCTIONAL_REQUIREMENTS);
+    const tested = new Set(testedItems.filter((item) => !marksRegenerateAgain(item)).map((item) => item.markdown.trim()));
+    const replaced = new Set(testedItems.filter((item) => marksRegenerateAgain(item)).map((item) => item.markdown.trim()));
     for (const item of items) {
-        if (item.section !== FUNCTIONAL_REQUIREMENTS || tested.size === 0)
+        if (item.section !== FUNCTIONAL_REQUIREMENTS || testedItems.length === 0)
             continue;
         if (item.state === "removed") {
-            if (tested.has(item.text.trim()))
+            if (tested.has(item.text.trim()) || replaced.has(item.text.trim()))
                 item.tests = "removed";
         }
         else if (tested.has(item.text.trim()))
             item.tests = "now";
-        else if (item.was !== undefined && tested.has(item.was.trim()))
+        else if (replaced.has(item.text.trim()) || (item.was !== undefined && (tested.has(item.was.trim()) || replaced.has(item.was.trim()))))
             item.tests = "older";
     }
     return keyed(items);

package/dist/run-report.d.ts

@@ -1,4 +1,4 @@
-import type { Job } from "./regenerate/jobs.ts";
+import { type Job } from "./regenerate/jobs.ts";
 /**
  * A headless run's report: one JSON file, `turri regenerate --report <file>`, saying what the run did - how it ended,
  * what it spent, which pulses landed, how many functional specs are completed - for a benchmark or CI to read rather

package/dist/run-report.js

@@ -2,6 +2,7 @@ import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { turriIdentity } from "./environment.js";
 import { onModelEvent } from "./regenerate/activity.js";
+import { firstRegeneration } from "./regenerate/jobs.js";
 /**
  * A headless run's report: one JSON file, `turri regenerate --report <file>`, saying what the run did - how it ended,
  * what it spent, which pulses landed, how many functional specs are completed - for a benchmark or CI to read rather
@@ -177,7 +178,12 @@ export function startRunReport(options) {
             };
         });
         const ran = list.filter((pulse) => pulse.status !== "queued");
+        const first = firstRegeneration(jobs, startedAt);
+        const seconds = (ms) => (ms !== undefined ? Math.round(ms / 100) / 10 : null);
         return {
+            // The time to first regeneration - the first code pulse started - and to the first one landed, from the run's start.
+            first_started_seconds: seconds(first.started),
+            first_landed_seconds: seconds(first.landed),
             counts: {
                 total: ran.length,
                 landed: ran.filter((pulse) => pulse.landed).length,

package/dist/self-invocation.d.ts

@@ -20,6 +20,6 @@ export declare function selfInvocation(command: string): string | undefined;
  */
 export declare function askedForCommandLine(message: string): boolean;
 /** What the agent is told when the call is refused. */
-export declare function refusal(what: string): string;
+export declare function refusal(what: string, surface?: string): string;
 /** The instruction that goes into the conversation's system prompt. */
 export declare const TOOLS_NOT_CLI: string;

package/dist/self-invocation.js

@@ -88,12 +88,13 @@ export function askedForCommandLine(message) {
         /(^|\s)pi\s+-p\b/.test(text));
 }
 /** What the agent is told when the call is refused. */
-export function refusal(what) {
+export function refusal(what, surface) {
     const instead = what === "pi"
         ? "Do not start another agent: do the work here, with this conversation's tools."
         : `Use ${TOOL_FOR[what] ?? "the matching turri tool"} instead.`;
     return (`Not run: that starts turri${what === "pi" ? "'s agent" : ` ${what}`} again from the shell - a separate, headless ` +
-        "run outside this conversation, its jobs, the panel and /halt. " +
+        // In a host there is no panel: the person watches the pulses where its surface says.
+        (surface !== undefined ? "run outside this conversation and its pulses, where the person can neither watch it nor halt it. " : "run outside this conversation, its jobs, the panel and /halt. ") +
         `${instead} Run turri from the command line only when the user asks for that.`);
 }
 /** The instruction that goes into the conversation's system prompt. */

package/dist/skill-progress.d.ts

@@ -6,7 +6,7 @@
  *   brood       ✓ intent ━━━━ ⠋ stack ──── ○ testing ──── ○ product       phase 2 of 4
  *                 stack - the language, frameworks, storage and architecture
  *
- * The second line says what the phase it is in does: a phase's name alone - `groundwork` - says little to someone
+ * The second line says what the phase it is in does: a phase's name alone - `skeleton` - says little to someone
  * who has not read the skill.
  *
  * A skill of one phase, or none, has nothing to be partway through: its line is the spinner and its name alone.

package/dist/skill.d.ts

@@ -85,6 +85,11 @@ export interface Skill {
      * last answer is written with `write_spec_diff`, and changes the agent decides itself need no answer before them.
      */
     diffPerAnswer: string[];
+    /**
+     * Started only by the person, with its slash command - `/brood` - never by the model on its own
+     * (`metadata.command-only: true`): cultivate runs it only when the person has just typed its command.
+     */
+    commandOnly: boolean;
 }
 export declare function loadSkill(skillDir: string): Skill;
 export declare function readRubric(skill: Skill, review: {

package/dist/skill.js

@@ -131,6 +131,7 @@ export function loadSkill(skillDir) {
         paced: data.metadata?.paced !== false,
         questioning: capped,
         diffPerAnswer,
+        commandOnly: data.metadata?.["command-only"] === true,
     };
 }
 export function readRubric(skill, review) {

package/dist/skills.d.ts

@@ -28,3 +28,17 @@ export declare function discoverSkills(packageRoot: string, projectDir: string |
 export declare function catalogueLine(skill: FoundSkill): string;
 /** What is said under the list about the skills it leaves out. */
 export declare function leftOutNote(catalogue: SkillCatalogue): string;
+/**
+ * Which skills cultivate may start now. A skill marked command-only (`/brood`) waits for the person to type its command:
+ * the command lets it start once, and the run starting uses that up - the model cannot start it again later on its own.
+ */
+export declare function createCommandGate(): {
+    /** The person typed the skill's command. */
+    typed(name: string): void;
+    /** Whether cultivate may start it now. */
+    mayStart(skill: Pick<FoundSkill, "name" | "commandOnly">): boolean;
+    /** Its run started: the command is used up. */
+    started(name: string): void;
+};
+/** What cultivate says of a command-only skill the person did not start. */
+export declare function startedByCommandOnly(name: string): string;