@turri-dev/cli 0.1.25-next.d0c7575 → 0.1.25

package/README.md

@@ -50,7 +50,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, type: `/spawn a small API where people can register and sign in` - or `/brood` for an interview that settles each feature with you first.
+Once `turri` is running, say what you want - `a small API where people can register and sign in` - and **turri** starts the project and regenerates it at once.
 
 No project of your own yet? Build one of [**the examples**](examples/README.md) with turri, step by step.
 
@@ -147,17 +147,17 @@ cd ~/my-project
 turri
 ```
 
-Then start the interview:
+Then say what you want:
 
-> /brood a small API where people can register and sign in
+> A small API where people can register and sign in, in Python.
 
-It asks you about the problem, the stack and the product, writes \*\*\*plain, and builds each functionality as it is written. While it works:
+In a new project **turri** starts it itself, without asking how: it chooses the stack - the one you name, else a standard library stack this machine can build - writes the module and its unit testing script (and the conformance tests' when you ask for them), regenerates the smallest thing that runs at once, then the main thing you described, and says what it chose and what it would write next. Every change after is yours to ask for: **turri** writes it as \*\*\*plain and regenerates it. 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;
 - the **side panel** (`ctrl+h`) takes the screen and opens on **regen** - \*\*\*plain, every item marked planned, working, regenerated, validating, conform or needs you - and `p` turns it to the **pulses** (`/pulses`) - every pulse, running, queued and finished, and what each regenerates; what its agents did is in each pulse's log in `.turri/jobs/`, kept with `--debug` (`debug: true`);
 - **`/halt`** halts a pulse, **`/lineage`** shows every generation of a module, and the **`drift`** tool says what is left to regenerate;
-- **`/btw <question>`** asks turri something on the side - answered at once, even in the middle of a skill's interview (typed as the answer, under "Something else…"), and left out of the conversation;
+- **`/btw <question>`** asks turri something on the side - answered at once, even while a question waits for you (typed as the answer, under "Something else…"), and left out of the conversation;
 - **`/turri-config`** changes any setting of the project's `config.turri.yaml` - the models, review, conformance tests, how many pulses at once - and says when it takes effect: now, at your next message, or at the next pulse. No restart: `/turri-config review false`, or `/turri-config` alone to pick from the list;
 - **`/stack`** chooses the stack to build with, in a project whose backend and frontend each have their own testing scripts in `config.turri.<stack>.yaml` - `/stack backend`, `/stack none` - for the session (`--stack <name>` on the command line). The chat's model builds each part with its own stack by itself, pinned to that module's pulses.
 

package/dist/extension.d.ts

@@ -92,10 +92,6 @@ export declare function moduleNamedFirst(cwd: string, words: string[]): {
  * is set - else half this machine's cores, between one and four.
  */
 export declare function parallelJobs(cwd: string): number;
-/** The project's own files and a digest of each - not plain_modules, dependencies, or turri's and git's folders. */
-export declare function projectFiles(root: string): Map<string, string>;
-/** The files added, changed or removed between two digests of the project. */
-export declare function changedFiles(before: Map<string, string>, after: Map<string, string>): string[];
 /**
  * This machine, for the chat's agent, read afresh every turn: which wall is up under the agents' commands, whether the
  * machine has the toolchains the project's modules name, and what in its testing scripts it lacks - for the person to

package/dist/extension.js

@@ -1,6 +1,5 @@
 // Whether the terminal shows images, before anything draws: the banner's jellyfish is a picture or text.
 import "./terminal-images.js";
-import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { conversationCommand, conversationSettled, conversationWriting } from "./regenerate/conversation-writes.js";
@@ -29,6 +28,7 @@ import { askedForCommandLine, refusal, selfInvocation, TOOLS_NOT_CLI } from "./s
 import { NEW_PROJECT } from "./new-project.js";
 import { describeChoices, describeResolution, modelFor, resolveModel } from "./regenerate/engine.js";
 import { checkPlainFile, checkPlainTargets, formatCheckResults } from "./plain/check.js";
+import { changedFiles, projectFiles } from "./plain-files.js";
 import { whyFailed } from "./regenerate/diagnose-job.js";
 import { createWorkLoop, describeModules, isUpToDate, previewJobs } from "./regenerate/loop.js";
 import { brandNeon, brandPink, plainPaint } from "./regenerate/plain-palette.js";
@@ -618,7 +618,7 @@ function turriExtension(api, session, link) {
     registerBranding(pi, discoveredSkills);
     registerInterviewLog(pi);
     registerJobTools(pi, jobs, cwd);
-    // The skills the person starts themselves - brood, spawn, bud: each has its command, and cultivate starts it only
+    // The skills the person starts themselves - a project's, marked command-only: each has its command, and cultivate starts it only
     // once its command is typed, or picked among the options the conversation offers with ask_user.
     const gate = createCommandGate();
     // A skill picked is started at once, with what the person asked for: they never type its command after picking it.
@@ -667,7 +667,7 @@ function turriExtension(api, session, link) {
         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, and so is an option starting with it that they picked in your ask_user - /brood - an interview. Call cultivate for it at once, with what they said as context. Never call cultivate for one otherwise; for a new project, offer the choice as <new-project> says.",
+            "A skill marked as started only by the person runs only from its command: a message that is its command - /<name> what they want - is the person starting it, and so is an option starting with it that they picked in your ask_user. Call cultivate for it at once, with what they said as context. Never call cultivate for one otherwise.",
             // 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.",
@@ -817,8 +817,9 @@ function turriExtension(api, session, link) {
                             push(`    ${line}`);
                 },
             };
-            // What the run changes in the project - its specs, resources, scripts - is said with its result: a skill that
-            // writes nothing is not taken for one that did its work.
+            // What the run changes in the project's ***plain - its specs, resources, scripts - is said with its result: a skill
+            // that writes nothing is not taken for one that did its work. Only those: a release or a running app changes other
+            // files while it runs, and they are not its doing.
             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 });
@@ -847,8 +848,6 @@ function turriExtension(api, session, link) {
                 // pulses sees them without knowing a skill started them.
                 // Asked per job as it is queued, so a model chosen mid-interview applies from then on.
                 renderQueue: workLoopFor(jobs, cwd, ctx),
-                // A skill that waits for its builds and reads what they recorded - `mature` - sees the same jobs.
-                jobs,
                 // The person answers the skill's agent while it runs, so it can take "render these with ..." too.
                 // validate too: a skill validates what it wrote with the same check the conversation has.
                 sharedTools: [setRenderModelTool(pi, ctx), checkPlainTool(cwd), ...createWebTools()],
@@ -900,10 +899,14 @@ function turriExtension(api, session, link) {
             const noise = describeCaptured(captured);
             if (noise !== null)
                 push(noise);
-            const changes = changedFiles(filesBefore, projectFiles(cwd));
+            const changes = changedFiles(filesBefore, projectFiles(cwd, filesBefore.keys()));
+            // A skill that only reads and reports - an analysis - changes nothing, and its result is its verdict.
+            const writes = ["write", "edit", "bash", "change_plain"].some((tool) => skill.allowedTools.includes(tool));
             const changed = changes.length > 0
                 ? `It changed ${changes.length} file${changes.length === 1 ? "" : "s"} in the project: ${changes.join(", ")}.`
-                : "It changed no file in the project - whatever it said it wrote is not there. Say so to the user; do not report the work as done.";
+                : writes
+                    ? "It changed no file in the project - whatever it said it wrote is not there. Say so to the user; do not report the work as done."
+                    : "It only reads: what it found is the artifact below.";
             // A skill that edits the specs with the file tools builds nothing: the change is the conversation's to render.
             const specsChanged = changes.filter((path) => path.endsWith(".plain"));
             const unrendered = specsChanged.length > 0 && !skill.allowedTools.includes("change_plain")
@@ -989,7 +992,7 @@ function registerRegenerate(pi, cwd, jobs) {
                 say(`${relative(cwd, plainFile) || plainFile} does not parse, so nothing can be regenerated from it yet: ${check.error}`, "error");
                 return;
             }
-            // From scratch - started over, its code deleted - asked in the person's words: confirmed first, as it deletes.
+            // From scratch - started over, its code deleted - asked in the person's words: started at once, as asked.
             const scratch = asksFromScratch(guidance);
             // The whole chain with it - "from scratch, the whole chain" - every module it requires built again from the bottom.
             const chain = scratch && asksWholeChain(guidance);
@@ -998,13 +1001,6 @@ function registerRegenerate(pi, cwd, jobs) {
                 say("Name functionalities or ask for it from scratch, not both: from scratch regenerates every one of them.", "warning");
                 return;
             }
-            if (scratch && ctx.hasUI) {
-                const agreed = await ctx.ui.confirm(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 ***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;
-            }
             const loop = workLoopFor(jobs, cwd, ctx);
             const model = jobModel(ctx, again.length > 0 ? "functionalities" : "spec_changes", undefined, plainFile);
             const request = { ...(model !== undefined ? { model } : {}), ...(guidance !== "" ? { guidance } : {}) };
@@ -1242,44 +1238,6 @@ function configOf(plainFile) {
 export function parallelJobs(cwd) {
     return readProjectConfig(cwd).parallelJobs ?? defaultParallelJobs();
 }
-/** The project's own files and a digest of each - not plain_modules, dependencies, or turri's and git's folders. */
-export function projectFiles(root) {
-    const files = new Map();
-    const walk = (dir, depth) => {
-        if (depth > 8)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (entry.name.startsWith(".") || entry.name === "plain_modules" || entry.name === "node_modules" || entry.name === "__pycache__")
-                continue;
-            const path = join(dir, entry.name);
-            if (entry.isDirectory())
-                walk(path, depth + 1);
-            else if (entry.isFile()) {
-                try {
-                    files.set(relative(root, path), createHash("sha1").update(readFileSync(path)).digest("hex"));
-                }
-                catch {
-                    // A file that cannot be read is left out.
-                }
-            }
-        }
-    };
-    walk(root, 0);
-    return files;
-}
-/** The files added, changed or removed between two digests of the project. */
-export function changedFiles(before, after) {
-    const changed = [...after].filter(([path, digest]) => before.get(path) !== digest).map(([path]) => path);
-    const removed = [...before.keys()].filter((path) => !after.has(path)).map((path) => `${path} (removed)`);
-    return [...changed, ...removed].sort();
-}
 /**
  * This machine, for the chat's agent, read afresh every turn: which wall is up under the agents' commands, whether the
  * machine has the toolchains the project's modules name, and what in its testing scripts it lacks - for the person to

package/dist/genome.d.ts

@@ -2,7 +2,6 @@ import { type Reporter } from "./graph.ts";
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { type Skill } from "./skill.ts";
 import { type AskUser } from "./tools.ts";
-import type { JobRegistry } from "./regenerate/jobs.ts";
 import type { WorkLoop } from "./regenerate/loop.ts";
 export interface EscalationRequest {
     step: string;
@@ -56,8 +55,6 @@ export interface RunSkillOptions {
      * builds stand - and regenerate and halt for a skill that names them in its allowed-tools.
      */
     loopTools?: ToolDefinition[];
-    /** The jobs the render queue runs, for a skill that waits for its builds and reads what they recorded. */
-    jobs?: JobRegistry;
     /**
      * Stops the run: its agents end their turns and it throws JobStoppedError, its manifest left as it was - an
      * interrupted run, for `resume` to pick up. What it started on the work loop goes on.

package/dist/genome.js

@@ -3,6 +3,7 @@ import { join, resolve } from "node:path";
 import { Command, MemorySaver } from "@langchain/langgraph";
 import { compileSkill } from "./graph.js";
 import { createExecutor } from "./pi.js";
+import { plainWriteTools } from "./plain-files.js";
 import { toolchainsBlock } from "./stack.js";
 import { clearOfStop, describeToolCall, describeToolResult, withStopSignal } from "./regenerate/activity.js";
 import { createLiveReviewer } from "./review/live.js";
@@ -11,7 +12,6 @@ import { createAskUserTool, createEndQuestionsTool, createReviewTools, createWri
 import { DECLINED, DISMISSED } from "./ask.js";
 import { createQuestioning, levelOf, questioningQuestion } from "./questioning.js";
 import { createSpecDiffTools } from "./spec-tools.js";
-import { createMatureTools, MATURE_TOOLS } from "./mature-tools.js";
 const CHANGE_PLAIN = "change_plain";
 /** The conversation's tools a skill acts on the work loop with - never pi built-ins. */
 const LOOP_TOOLS = ["regenerate", "drift", "halt", "conform"];
@@ -28,7 +28,6 @@ export async function runSkill(opts) {
     return withStopSignal(opts.signal, () => runStoppable({
         ...opts,
         ...(opts.renderQueue !== undefined ? { renderQueue: clearOfStop(opts.renderQueue) } : {}),
-        ...(opts.jobs !== undefined ? { jobs: clearOfStop(opts.jobs) } : {}),
         ...(opts.loopTools !== undefined ? { loopTools: opts.loopTools.map(clearOfStop) } : {}),
     }));
 }
@@ -128,14 +127,12 @@ async function runStoppable(opts) {
     }
     if (diffs !== undefined)
         customTools.push(...diffs.tools);
-    // A skill that builds what the spec holds, waits for it, and reads back where the builds had to guess.
-    if (opts.renderQueue !== undefined && opts.jobs !== undefined && skill.allowedTools.some((tool) => MATURE_TOOLS.includes(tool))) {
-        customTools.push(...createMatureTools({ jobs: opts.jobs, cwd: opts.cwd }));
-    }
     customTools.push(...(opts.sharedTools ?? []));
+    // Its write and edit reach the project's ***plain only - not the code, a release, or what an app it started writes.
+    customTools.push(...plainWriteTools(opts.cwd).filter((tool) => skill.allowedTools.includes(tool.name)));
     const names = customTools.map((tool) => tool.name);
     // Tools this harness provides are never pi built-ins, even when it did not provide them.
-    const builtins = skill.allowedTools.filter((t) => !names.includes(t) && t !== CHANGE_PLAIN && !MATURE_TOOLS.includes(t) && !LOOP_TOOLS.includes(t));
+    const builtins = skill.allowedTools.filter((t) => !names.includes(t) && t !== CHANGE_PLAIN && !LOOP_TOOLS.includes(t));
     const executor = await createExecutor({
         cwd: opts.cwd,
         customTools,

package/dist/graph.js

@@ -87,8 +87,8 @@ function stepPrompt(skill, step, critique, context) {
         `This skill's own files are in ${skill.dir}: a path its steps name, such as references/<file>.md, is there. ` +
             `A skill it says to follow is beside it, in ${dirname(skill.dir)}/<skill name>/SKILL.md - read it and follow it.`,
         "",
-        // The artifact exists for the gate's judges to read. Without a gate nothing reads it,
-        // and asking for one is a tool call spent on a file no one opens.
+        // The artifact exists for the gate's judges to read. Without a gate its reply is what the step gives,
+        // and asking for a file is a tool call spent on what the reply already says.
         step.gate
             ? `When you are done, call write_artifact with path "${artifactPath(step)}" holding the record the review will be checked against.`
             : "",
@@ -133,6 +133,9 @@ export function compileSkill(opts) {
             catch {
                 // Left empty on purpose: the gate treats a missing artifact as a failure.
             }
+            // A step with no gate is asked for no artifact: what it found is its reply - an analysis's verdict, all it gives.
+            if (artifact === "" && !step.gate)
+                artifact = reply.trim();
             if (artifact)
                 report.artifact(artifactPath(step), artifact);
             return {

package/dist/new-project.d.ts

@@ -1,7 +1,5 @@
 /**
  * Starting a project from the conversation: the person says what they want built - "create a small server in Java
- * Spring Boot" - and the chat offers the three ways to start it: brood's interview, spawn's quick start, or writing the
- * ***plain itself, here, with no skill. An option picked that starts with a skill's command starts that skill, as if
- * typed (`chosenCommand` in skills.ts).
+ * Spring Boot" - and the chat writes the ***plain itself, here, with no skill, regenerating from the first functional spec.
  */
 export declare const NEW_PROJECT: string;

package/dist/new-project.js

@@ -1,21 +1,11 @@
 /**
  * Starting a project from the conversation: the person says what they want built - "create a small server in Java
- * Spring Boot" - and the chat offers the three ways to start it: brood's interview, spawn's quick start, or writing the
- * ***plain itself, here, with no skill. An option picked that starts with a skill's command starts that skill, as if
- * typed (`chosenCommand` in skills.ts).
+ * Spring Boot" - and the chat writes the ***plain itself, here, with no skill, regenerating from the first functional spec.
  */
 export const NEW_PROJECT = [
     "<new-project>",
-    "When the person asks for new software / project ",
-    "and there is no ***plain module for it yet, or they ask for a new project, ask them first how to start it, with",
-    "ask_user: one question, these three options, word for word, so they know the skills are there:",
-    `- "${"/brood - an interview: the stack, the testing and every feature settled with you, each answer regenerated"}"`,
-    `- "${"/spawn - something running in minutes: the quick start, asking the stack in one question unless your message names it"}"`,
-    `- "${"Just do it - no skill: I write it here and start regenerating"}"`,
-    "Picked /brood or /spawn: the answer starts it - call cultivate for it at once, with what they said as its context,",
-    "never asking them to type its command. Do not ask when their",
-    "message says already - they typed the command, or said to just build it, with no skill, without questions: then",
-    "start it yourself. Started yourself, how soon the first pulse starts, and something they can try, come first:",
+    "When the person asks for new software / project and there is no ***plain module for it yet, or they ask for a new",
+    "project, start it yourself, without asking how. How soon the first pulse starts, and something they can try, come first:",
     "1. The stack: the one they named; otherwise one of the standard library's that this machine can build - common,",
     "   simple - said in a line. A stack named in a language the machine lacks is written all the same: tell them what to",
     "   install, and that turri doctor checks it. Read the stack's template, its language's and its kind's common first.",

package/dist/plain/parser.d.ts

@@ -21,6 +21,7 @@ export interface PlainFileParseResult {
 }
 export declare function getFilenameFromModuleName(moduleName: string): string;
 export declare function getModuleNameFromFilename(filename: string): string;
+export declare function hasScheme(target: string): boolean;
 /** The links written in an item - what each says and where it points - as the parser reads them, checked or not. */
 export declare function linksIn(section: AnyNode): Array<{
     text: string;

package/dist/plain/parser.js

@@ -27,7 +27,7 @@ export function getFilenameFromModuleName(moduleName) {
 export function getModuleNameFromFilename(filename) {
     return filename.split(PLAIN_SOURCE_FILE_EXTENSION).join("");
 }
-function hasScheme(target) {
+export function hasScheme(target) {
     return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(target);
 }
 /**

package/dist/plain-files.d.ts

@@ -0,0 +1,21 @@
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+/**
+ * The project's ***plain and what it is built with, and a digest of each: its .plain files, the resources they link,
+ * its testing scripts and its config.turri*.yaml. Nothing else is a skill's to change - not the built code, a release,
+ * what a running app writes. `also`: paths that were among them before, digested while they are there, so one a skill
+ * stopped linking or naming is still seen if it changed it.
+ */
+export declare function projectFiles(root: string, also?: Iterable<string>): Map<string, string>;
+/** The files added, changed or removed between two digests of the project. */
+export declare function changedFiles(before: Map<string, string>, after: Map<string, string>): string[];
+/**
+ * Why a skill's agent may not write a path, or nothing when it may. It writes the project's ***plain: a file of it
+ * (`projectFiles`), or a new one - a resource it is about to link, a testing script - anywhere in the project but where
+ * what is built, released or installed lives. Never an existing file that is not the ***plain's: the code, a release,
+ * what an app it started writes.
+ */
+export declare function plainWriteRefusal(root: string, path: string): string | undefined;
+type AnyTool = ToolDefinition<any, any, any>;
+/** pi's write and edit for a skill's agent: each path checked by `plainWriteRefusal` - as given, and as the tool resolved it. */
+export declare function plainWriteTools(root: string): AnyTool[];
+export {};

package/dist/plain-files.js

@@ -0,0 +1,156 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createEditToolDefinition, createWriteToolDefinition } from "@earendil-works/pi-coding-agent";
+import { readProjectConfig, stacksOf } from "./config.js";
+import { parseMarkdown } from "./plain/markdown.js";
+import { hasScheme, linksIn } from "./plain/parser.js";
+import { insideAny } from "./regenerate/confine.js";
+import { credentialRefusal, isCredentialFile } from "./regenerate/credentials.js";
+import { DIST_DIR, MODULES_DIR } from "./regenerate/paths.js";
+import { PREPARE_NAME, SCRIPTS_DIR, scriptKind } from "./regenerate/test-scripts.js";
+/** A config.turri.yaml, a stack's config.turri.<stack>.yaml - what the project's testing scripts are named in. */
+const TURRI_CONFIG_NAME = /^config\.turri(\.[^/]+)?\.yaml$/;
+/** Folders that hold what is built, installed or turri's own - never the project's ***plain. */
+function outsidePlain(path) {
+    const parts = path.split(sep);
+    return parts[0] === DIST_DIR || parts.some((part) => part.startsWith(".") || part === MODULES_DIR || part === "node_modules" || part === "__pycache__");
+}
+/**
+ * The project's ***plain and what it is built with, and a digest of each: its .plain files, the resources they link,
+ * its testing scripts and its config.turri*.yaml. Nothing else is a skill's to change - not the built code, a release,
+ * what a running app writes. `also`: paths that were among them before, digested while they are there, so one a skill
+ * stopped linking or naming is still seen if it changed it.
+ */
+export function projectFiles(root, also = []) {
+    const all = [];
+    const walk = (dir, depth) => {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || entry.name === MODULES_DIR || entry.name === "node_modules" || entry.name === "__pycache__")
+                continue;
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(path, depth + 1);
+            else if (entry.isFile())
+                all.push(relative(root, path));
+        }
+    };
+    walk(root, 0);
+    const wanted = new Set(also);
+    const named = (path) => {
+        if (path !== undefined && path.trim() !== "")
+            wanted.add(relative(root, resolve(root, path.trim())));
+    };
+    for (const path of all) {
+        const name = basename(path);
+        if (path.split(sep)[0] === SCRIPTS_DIR || scriptKind(name) !== undefined || PREPARE_NAME.test(name) || TURRI_CONFIG_NAME.test(name))
+            wanted.add(path);
+        if (!path.endsWith(".plain"))
+            continue;
+        wanted.add(path);
+        // The resources it links, as the parser reads its links: from the project's folder.
+        try {
+            for (const { target } of linksIn(parseMarkdown(readFileSync(join(root, path), "utf8")))) {
+                if (target !== "" && !hasScheme(target) && !isAbsolute(target))
+                    named(target);
+            }
+        }
+        catch {
+            // A file that cannot be read links nothing.
+        }
+    }
+    // Scripts config.turri*.yaml names, whatever they are called.
+    for (const stack of [undefined, ...stacksOf(root)]) {
+        const config = readProjectConfig(root, stack);
+        named(config.unittestsScript);
+        named(config.conformanceTestsScript);
+        named(config.prepareEnvironmentScript);
+    }
+    const files = new Map();
+    for (const path of wanted) {
+        if (path.startsWith("..") || isAbsolute(path) || path.split(sep).includes(MODULES_DIR))
+            continue;
+        try {
+            files.set(path, createHash("sha1").update(readFileSync(join(root, path))).digest("hex"));
+        }
+        catch {
+            // A file that cannot be read, or is not there, is left out.
+        }
+    }
+    return files;
+}
+/** The files added, changed or removed between two digests of the project. */
+export function changedFiles(before, after) {
+    const changed = [...after].filter(([path, digest]) => before.get(path) !== digest).map(([path]) => path);
+    const removed = [...before.keys()].filter((path) => !after.has(path)).map((path) => `${path} (removed)`);
+    return [...changed, ...removed].sort();
+}
+/**
+ * Why a skill's agent may not write a path, or nothing when it may. It writes the project's ***plain: a file of it
+ * (`projectFiles`), or a new one - a resource it is about to link, a testing script - anywhere in the project but where
+ * what is built, released or installed lives. Never an existing file that is not the ***plain's: the code, a release,
+ * what an app it started writes.
+ */
+export function plainWriteRefusal(root, path) {
+    const absolute = resolve(root, path);
+    if (!insideAny(absolute, [root]))
+        return `${absolute} is outside the project. A skill writes the project's ***plain, and nothing else.`;
+    if (isCredentialFile(absolute))
+        return credentialRefusal(absolute);
+    const inProject = relative(resolve(root), absolute);
+    if (outsidePlain(inProject)) {
+        return (`${inProject} is not the project's ***plain - ${MODULES_DIR}/, ${DIST_DIR}/ and the hidden folders hold what is ` +
+            "built, released and installed, and turri's own. A skill writes .plain files, the resources they link and the testing scripts.");
+    }
+    if (existsSync(absolute) && !projectFiles(root).has(inProject)) {
+        return (`${inProject} is not the project's ***plain: no .plain file links it, and it is not a testing script or a ` +
+            "config.turri*.yaml. A skill changes only those - link a resource from the ***plain before changing it.");
+    }
+    return undefined;
+}
+/** pi's write and edit for a skill's agent: each path checked by `plainWriteRefusal` - as given, and as the tool resolved it. */
+export function plainWriteTools(root) {
+    const check = (path) => {
+        if (path === undefined)
+            return;
+        const refusal = plainWriteRefusal(root, path.trim().replace(/^@/, ""));
+        if (refusal !== undefined)
+            throw new Error(refusal);
+    };
+    const guard = (def) => ({
+        ...def,
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
+            check(params.path);
+            return def.execute(toolCallId, params, signal, onUpdate, ctx);
+        },
+    });
+    return [
+        guard(createWriteToolDefinition(root, {
+            operations: {
+                writeFile: async (path, content) => (check(path), writeFileSync(path, content)),
+                // A folder that is there already is not written: only where it would be made is checked.
+                mkdir: async (dir) => {
+                    if (!existsSync(dir))
+                        check(dir);
+                    mkdirSync(dir, { recursive: true });
+                },
+            },
+        })),
+        guard(createEditToolDefinition(root, {
+            operations: {
+                readFile: async (path) => (check(path), readFileSync(path)),
+                writeFile: async (path, content) => (check(path), writeFileSync(path, content)),
+                access: async (path) => check(path),
+            },
+        })),
+    ];
+}

package/dist/regenerate/diff-view.d.ts

@@ -21,12 +21,15 @@ export interface DiffPaint {
 export declare const PLAIN_PAINT: DiffPaint;
 /**
  * Where the lines of a diff are in the .plain files: by a line's place in the diff, the file it is in and its
- * line there. Only lines that are in a file - added and unchanged ones; a removed line is in none now.
+ * line there. Only lines that are in a file - added and unchanged ones; a removed line is in none now. `written`
+ * is the line as the file has it - its links as written, not as the diff reads them - so a host can find it
+ * again in the file's text once it is edited; absent in a ledger written before it.
  */
 export type DiffWhere = Record<number, {
     file: string;
     line: number;
     section?: string;
+    written?: string;
 }>;
 /**
  * Place a spec diff's lines in the .plain files they come from - `files`, the module's and every one it

package/dist/regenerate/diff-view.js

@@ -25,7 +25,10 @@ function asRead(line) {
 export function locateDiffLines(diff, files) {
     const where = {};
     // Each line as the parser renders it: a link `[text](path)` is the span `` `[resource]text` `` in the spec as read.
-    const texts = files.map((file) => ({ name: file.name, lines: file.text.split("\n").map((line) => asRead(line.trimEnd())) }));
+    const texts = files.map((file) => {
+        const written = file.text.split("\n").map((line) => line.trimEnd());
+        return { name: file.name, written, lines: written.map(asRead) };
+    });
     // The section each line of a file is in: the nearest `***...***` header above it, or on it.
     const sections = texts.map((file) => {
         let current;
@@ -36,7 +39,7 @@ export function locateDiffLines(diff, files) {
     const take = (file, line, index) => {
         used.add(`${file}:${line}`);
         const section = sections[file][line];
-        where[index] = { file: texts[file].name, line: line + 1, ...(section !== undefined ? { section } : {}) };
+        where[index] = { file: texts[file].name, line: line + 1, ...(section !== undefined ? { section } : {}), written: texts[file].written[line] };
         last = { file, line };
     };
     diff
@@ -54,7 +57,7 @@ export function locateDiffLines(diff, files) {
             if (file !== -1) {
                 const at = texts[file].lines.indexOf(removed);
                 const section = sections[file][at];
-                where[index] = { file: texts[file].name, line: at + 1, ...(section !== undefined ? { section } : {}) };
+                where[index] = { file: texts[file].name, line: at + 1, ...(section !== undefined ? { section } : {}), written: texts[file].written[at] };
             }
             return;
         }

package/dist/regenerate/stop-report.js

@@ -42,7 +42,7 @@ export function describeStop(facts) {
         why = `after ${tries} attempt${tries === 1 ? "" : "s"} it still could not be built to pass its own unit tests.`;
         todo = [
             "The functional spec is most likely too big for one functionality, or leaves a choice open that keeps coming " +
-                "out wrong. Split it into smaller functional specs (`analyze-if-func-spec-too-complex`, `break-down-func-spec`), " +
+                "out wrong. Split it into smaller functional specs (`break-down-func-spec`), " +
                 "or say exactly what it should do.",
             "If it needs something the stack does not name - a library, a tool, a service - add it to the implementation reqs.",
             "If its unit tests have to be run in a particular way, say how in the implementation reqs.",

package/dist/regenerate/test-scripts.d.ts

@@ -49,6 +49,8 @@ export interface TestScripts {
  */
 export declare function withoutConformance(scripts: TestScripts): TestScripts;
 export declare function scriptKind(name: string): ScriptKind | undefined;
+/** The name the prepare script has: `prepare_environment_<lang>.sh`. */
+export declare const PREPARE_NAME: RegExp;
 export declare const SCRIPTS_DIR = "test_scripts";
 /**
  * The project a build belongs to: the folder that holds its plain_modules. A build folder

package/dist/regenerate/test-scripts.js

@@ -30,7 +30,7 @@ export function scriptKind(name) {
     return Object.keys(NAMES).find((kind) => NAMES[kind].test(basename(name)));
 }
 /** The name the prepare script has: `prepare_environment_<lang>.sh`. */
-const PREPARE_NAME = /^prepare_environment[^/]*\.sh$/i;
+export const PREPARE_NAME = /^prepare_environment[^/]*\.sh$/i;
 function isFile(path) {
     try {
         return statSync(path).isFile();

package/dist/skill-progress.d.ts

@@ -1,12 +1,12 @@
 /**
  * A skill's run as one line above the input: every phase by name, in order - the ones done ticked, the one it is in
- * marked, the rest to come - and where that is, phase 2 of 4. `brood` and `spawn` take many turns of
- * questions and spec changes; without it, nothing on the screen says how far through they are.
+ * marked, the rest to come - and where that is, phase 2 of 4. A skill of many phases takes many turns of
+ * questions and ***plain changes; without it, nothing on the screen says how far through it is.
  *
- *   brood       ✓ intent ━━━━ ⠋ stack ──── ○ testing ──── ○ product       phase 2 of 4
+ *   onboard     ✓ intent ━━━━ ⠋ stack ──── ○ product       phase 2 of 3
  *                 stack - the language, frameworks, storage and architecture
  *
- * The second line says what the phase it is in does: a phase's name alone - `skeleton` - says little to someone
+ * The second line says what the phase it is in does: a phase's name alone - `stack` - 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

@@ -86,7 +86,7 @@ export interface Skill {
      */
     diffPerAnswer: string[];
     /**
-     * Started only by the person, with its slash command - `/brood` - never by the model on its own
+     * Started only by the person, with its slash command - `/release-notes` - 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;