@turri-dev/cli 0.0.0-stage → 0.1.2-next.48dacfc

package/dist/genome.js

@@ -0,0 +1,301 @@
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Command, MemorySaver } from "@langchain/langgraph";
+import { compileSkill } from "./graph.js";
+import { createExecutor } from "./pi.js";
+import { toolchainsBlock } from "./stack.js";
+import { describeToolCall, describeToolResult } from "./regenerate/activity.js";
+import { createLiveReviewer } from "./review/live.js";
+import { loadSkill, readRubric } from "./skill.js";
+import { createAskUserTool, createEndQuestionsTool, createReviewTools, createWriteArtifactTool, withReviewNote } from "./tools.js";
+import { 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 WRITE_SPEC_DIFF = "write_spec_diff";
+/** The conversation's tools a skill acts on the work loop with - never pi built-ins. */
+const LOOP_TOOLS = ["regenerate", "drift", "halt", "conform"];
+/** How much of what the agent said before a question is shown with it: its end, where the brief is. */
+const SAID_MAX = 6000;
+/**
+ * Run one skill to completion. The only entry point: the CLI and the Pi extension
+ * both go through here, so a skill behaves identically whether a human launched it
+ * or a conversational agent decided to.
+ */
+export async function runSkill(opts) {
+    const skill = loadSkill(opts.skillDir);
+    const runDir = resolve(opts.runDir);
+    // A resumed run keeps its folder - the artifacts are in it - and starts where it stopped.
+    let resumed;
+    if (opts.resume === true) {
+        resumed = readManifest(runDir);
+        if (resumed === undefined || resumed.skill !== skill.name || resumed.status !== "running") {
+            throw new Error(resumed === undefined || resumed.skill !== skill.name
+                ? `There is no interrupted run of ${skill.name} to resume here.`
+                : `The last run of ${skill.name} here ${resumed.status === "finished" ? "finished" : "was stopped"}; there is nothing to resume.`);
+        }
+    }
+    else {
+        rmSync(runDir, { recursive: true, force: true });
+    }
+    mkdirSync(runDir, { recursive: true });
+    // The executor has to exist before a reviewer can borrow its auth, and the reviewer has
+    // to exist before the tools that report its findings. So the tool list is built in two
+    // passes with a box the reviewer is dropped into once there is one.
+    const liveReviewers = new Map();
+    const liveStep = skill.steps.find((step) => step.gate?.continuous !== undefined);
+    const holder = {};
+    const liveProxy = liveStep === undefined
+        ? undefined
+        : {
+            notice: (scope) => holder.reviewer?.notice(scope),
+            take: () => holder.reviewer?.take() ?? [],
+            takeQuestions: () => holder.reviewer?.takeQuestions() ?? [],
+            reply: (id, answer) => holder.reviewer?.reply(id, answer) ?? false,
+            settle: async () => holder.reviewer?.settle() ?? { clean: true, findings: [] },
+            history: () => holder.reviewer?.history() ?? [],
+            passes: () => holder.reviewer?.passes() ?? 0,
+        };
+    const writeArtifact = createWriteArtifactTool(runDir);
+    const customTools = [writeArtifact];
+    // The questioning level, asked first in a skill whose phases it caps - when there is someone to ask. A resumed run
+    // keeps the one it was given, and how far each phase's questions went.
+    const capsQuestions = skill.questioning.length > 0 && opts.askUser !== undefined;
+    let questioning;
+    const keepQuestioning = (state) => {
+        manifest.questioning = state;
+        writeManifest(runDir, manifest);
+    };
+    const startQuestioning = (level, from) => (questioning = createQuestioning({ level: levelOf(level), phases: skill.questioning, from, onChange: keepQuestioning }));
+    if (capsQuestions && resumed?.questioning !== undefined)
+        startQuestioning(resumed.questioning.level, resumed.questioning);
+    // The step running now, and whether each of its answers is a spec change: then the next question waits until the last
+    // answer is written, and a change the agent decides itself needs no answer before it.
+    let currentStep = "";
+    const diffPerAnswer = () => skill.diffPerAnswer.includes(currentStep);
+    const holdsQuestions = capsQuestions || (skill.diffPerAnswer.length > 0 && opts.askUser !== undefined);
+    const questions = {
+        refusal: (confirmsPhase) => diffPerAnswer() && diffs?.pace.owed() === true
+            ? "This question was not asked: the last answer is not in the spec yet. Every answer in this phase is a spec " +
+                "change, built at once - write it with write_spec_diff first, then ask."
+            : questioning?.refusal(confirmsPhase),
+        answered: (confirmsPhase) => questioning?.answered(confirmsPhase),
+        end: () => questioning?.end() ?? "No questioning level was chosen: ask what the phase needs.",
+    };
+    // A skill whose unit of work is a spec change gets write_spec_diff: the change is applied
+    // and its build queued in one step.
+    const diffs = opts.renderQueue !== undefined && skill.allowedTools.includes(WRITE_SPEC_DIFF)
+        ? createSpecDiffTools({
+            loop: opts.renderQueue,
+            cwd: opts.cwd,
+            liveReview: liveProxy,
+            paced: skill.paced,
+            free: diffPerAnswer,
+        })
+        : undefined;
+    // What the agent says between its questions - a brief to confirm, a plan - reaches the person only with
+    // the next question: the session it talks in is its own, and nobody reads it.
+    let said = "";
+    /** A new message of the agent's has started, and has said nothing yet. */
+    let saidFresh = false;
+    if (opts.askUser !== undefined) {
+        customTools.push(createAskUserTool(opts.askUser, (answer, confirmsPhase) => {
+            said = "";
+            // A phase's confirmation, or a question dismissed, owes the spec nothing.
+            diffs?.pace.answered(!confirmsPhase && answer !== DISMISSED);
+        }, () => said, holdsQuestions ? questions : undefined));
+        if (capsQuestions)
+            customTools.push(createEndQuestionsTool(questions));
+    }
+    if (opts.renderQueue !== undefined) {
+        customTools.push(...createReviewTools(liveProxy));
+        for (const tool of opts.loopTools ?? []) {
+            if (tool.name === "drift")
+                customTools.push(withReviewNote(tool, liveProxy));
+            else if (skill.allowedTools.includes(tool.name))
+                customTools.push(tool);
+        }
+    }
+    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 ?? []));
+    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 !== WRITE_SPEC_DIFF && !MATURE_TOOLS.includes(t) && !LOOP_TOOLS.includes(t));
+    const executor = await createExecutor({
+        cwd: opts.cwd,
+        customTools,
+        tools: [...builtins, ...names],
+        model: opts.model,
+        // A skill writes specs; the rules it is held to are in its system prompt - and what this machine can build, so the
+        // stack it offers or chooses is one that can be regenerated here.
+        rules: true,
+        system: toolchainsBlock(),
+        resumeFrom: resumed?.sessionFile,
+    });
+    const manifest = resumed ?? {
+        skill: skill.name,
+        status: "running",
+        artifacts: {},
+        attempts: {},
+        updatedAt: "",
+    };
+    // What the agent does, as it does it: its session is its own, so without this a long step is silence.
+    executor.subscribe((event) => {
+        if (event.type === "tool_execution_start") {
+            opts.report.activity?.(describeToolCall(event.toolName, event.args));
+            return;
+        }
+        if (event.type === "tool_execution_end") {
+            const line = describeToolResult(event.toolName, event.result, event.isError);
+            if (line !== undefined)
+                opts.report.activity?.(line);
+            return;
+        }
+        // Shown with the next question is the last thing it said, not all it said since the last answer: a message of
+        // its own replaces what came before - its account of a probe, a regeneration - once it has words in it, so a brief
+        // said just before a bare ask_user call is still shown with it.
+        if (event.type === "message_start") {
+            if (event.message.role === "assistant")
+                saidFresh = true;
+            return;
+        }
+        if (event.type !== "message_update")
+            return;
+        const update = event.assistantMessageEvent;
+        if (update.type === "text_start") {
+            if (saidFresh)
+                said = "";
+            saidFresh = false;
+            if (said.trim() !== "")
+                said += "\n\n";
+            opts.report.said?.("", true);
+        }
+        else if (update.type === "text_delta") {
+            said = (said + update.delta).slice(-SAID_MAX);
+            opts.report.said?.(update.delta, false);
+        }
+    });
+    manifest.sessionFile = executor.sessionFile;
+    writeManifest(runDir, manifest);
+    // Built renders were lost with the process; queue what the specs hold that is not built.
+    if (resumed !== undefined && opts.renderQueue !== undefined) {
+        for (const file of plainFilesIn(opts.cwd))
+            void opts.renderQueue.bringUp(file).catch(() => undefined);
+    }
+    if (liveStep !== undefined && liveProxy !== undefined) {
+        const continuous = liveStep.gate.continuous;
+        holder.reviewer = createLiveReviewer({
+            cwd: opts.cwd,
+            spec: continuous,
+            rubric: readRubric(skill, continuous),
+            executor,
+            defaultModel: opts.model,
+            onPass: (pass) => opts.report.livePass?.(liveStep.name, pass.scope, pass.findings),
+        });
+        liveReviewers.set(liveStep.name, liveProxy);
+    }
+    try {
+        const app = compileSkill({
+            skill,
+            cwd: opts.cwd,
+            runDir,
+            executor,
+            report: opts.report,
+            model: opts.model,
+            context: opts.context,
+            liveReviewers,
+            startAt: resumed?.step,
+            // Where the run is, written as each step starts: what a resume picks up from.
+            onStepStart: (step, state) => {
+                manifest.step = step;
+                manifest.artifacts = state.artifacts;
+                manifest.attempts = state.attempts;
+                writeManifest(runDir, manifest);
+            },
+            beforeStep: async (step) => {
+                currentStep = step;
+                if (!capsQuestions)
+                    return;
+                // The first question of the first phase is the harness's: how many the capped phases may ask.
+                if (questioning === undefined) {
+                    const asked = questioningQuestion(skill.questioning);
+                    startQuestioning(await opts.askUser({ ...asked, said: "" }));
+                    keepQuestioning(questioning.state());
+                }
+                questioning.enter(step);
+            },
+            stepNote: (step) => questioning?.note(step, step === skill.steps[0].name),
+        }).compile({
+            checkpointer: new MemorySaver(),
+        });
+        const config = { configurable: { thread_id: `genome-${Date.now()}` }, recursionLimit: 50 };
+        let result = await app.invoke(resumed !== undefined ? { artifacts: resumed.artifacts, attempts: resumed.attempts } : {}, config);
+        // Escalation surfaces as a LangGraph interrupt: the graph is paused, not
+        // finished, and nothing advances until the handler answers.
+        while (result.__interrupt__?.length) {
+            const approved = await opts.escalate(result.__interrupt__[0].value);
+            result = await app.invoke(new Command({ resume: { approved } }), config);
+        }
+        const artifacts = result.artifacts ?? {};
+        const lastStep = skill.steps[skill.steps.length - 1].name;
+        manifest.status = result.decision === "abort" ? "stopped" : "finished";
+        writeManifest(runDir, manifest);
+        return {
+            skill,
+            ok: result.decision !== "abort",
+            artifacts,
+            output: artifacts[lastStep] ?? "",
+        };
+    }
+    finally {
+        executor.dispose();
+    }
+}
+const MANIFEST = "run.json";
+function readManifest(runDir) {
+    try {
+        return JSON.parse(readFileSync(join(runDir, MANIFEST), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeManifest(runDir, manifest) {
+    manifest.updatedAt = new Date().toISOString();
+    writeFileSync(join(runDir, MANIFEST), JSON.stringify(manifest, null, 2));
+}
+/** The .plain files at the top of a project. */
+function plainFilesIn(dir) {
+    try {
+        return readdirSync(dir)
+            .filter((name) => name.endsWith(".plain"))
+            .map((name) => join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+/** Whether there is a run of this skill here that was interrupted, and could be resumed. */
+export function interruptedRun(runDir, skillName) {
+    const manifest = readManifest(resolve(runDir));
+    return manifest?.skill === skillName && manifest.status === "running"
+        ? { step: manifest.step, updatedAt: manifest.updatedAt }
+        : undefined;
+}
+/** Human-readable one-liner per step, for logs and tool output. */
+export function describeGates(skill) {
+    return skill.steps.map((s) => {
+        if (!s.gate)
+            return `${s.name} -> no gate`;
+        const live = s.gate.continuous
+            ? ` + continuous(${s.gate.continuous.rubric}, judges=${s.gate.continuous.judges})`
+            : "";
+        const r = s.gate.review;
+        return `${s.name} -> gate(${r.rubric}, judges=${r.judges}, quorum=${r.quorum}, on_fail=${r.onFail}, max_retries=${r.maxRetries})${live}`;
+    });
+}

package/dist/graph.js

@@ -0,0 +1,246 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { Annotation, END, START, StateGraph, interrupt } from "@langchain/langgraph";
+import { runGate } from "./judge.js";
+import { ask } from "./pi.js";
+import { describeFindings } from "./review/live.js";
+import { readRubric } from "./skill.js";
+export const GenomeState = Annotation.Root({
+    artifacts: Annotation({
+        reducer: (a, b) => ({ ...a, ...b }),
+        default: () => ({}),
+    }),
+    attempts: Annotation({
+        reducer: (a, b) => ({ ...a, ...b }),
+        default: () => ({}),
+    }),
+    /** Judge feedback for the step currently being retried. */
+    critique: Annotation({ reducer: (_a, b) => b, default: () => "" }),
+    decision: Annotation({ reducer: (_a, b) => b, default: () => "advance" }),
+});
+const stepNode = (s) => `step.${s}`;
+const gateNode = (s) => `gate.${s}`;
+const escalateNode = (s) => `escalate.${s}`;
+/** Where the executor is required to put this step's deliverable. */
+const artifactPath = (step) => `${step.name}.md`;
+/**
+ * The prompt for a step picked up after the run was interrupted part-way through it. The
+ * session is the one that was running, so the step's instructions and everything said so far
+ * are already in it; what the agent needs is to know it stopped, and to look before it acts.
+ */
+function resumePrompt(step) {
+    return [
+        `This skill run was interrupted during step '${step.name}' and has been resumed. Your session is as`,
+        "it was when it stopped.",
+        "",
+        "Check what is already on disk before doing anything - the specs written so far, and any artifact -",
+        "and continue the step from where it stopped. Do not redo what is done, and do not ask the user again",
+        "for anything they have already answered.",
+        step.gate ? `\nWhen the step is done, call write_artifact with path "${artifactPath(step)}" as before.` : "",
+    ]
+        .filter((part) => part !== "")
+        .join("\n");
+}
+/** How many times a step whose turn ends on a question in its reply is sent back to carry on. */
+export const QUESTION_NUDGES = 2;
+/** Whether a reply ends on a question: its last line, its markdown left aside, ends with a question mark. */
+export function endsOnQuestion(reply) {
+    const last = reply.trim().split("\n").filter((line) => line.trim() !== "").at(-1) ?? "";
+    return /\?$/.test(last.replace(/[*_`)\]"'\s]+$/, ""));
+}
+/** Sent when a step's turn ended on a question in its reply: no one reads it, and the step is not done. */
+function unansweredQuestionPrompt(skill, step) {
+    return [
+        "Your turn ended on a question in your reply. No one reads it: the person sees only what ask_user asks, and",
+        `the step ends when your turn does - so step '${step.name}' would end here, not done.`,
+        skill.paced
+            ? "If it is truly the person's to decide, ask it with ask_user. Otherwise decide it yourself."
+            : `'${skill.name}' asks the person nothing more: decide it yourself, as a careful engineer would, and say what you chose.`,
+        `Then carry on with step '${step.name}' until all of it is done, and end your turn only then.`,
+    ].join("\n");
+}
+function stepPrompt(skill, step, critique, context) {
+    if (critique) {
+        return [
+            `Your previous attempt at step '${step.name}' was rejected by review.`,
+            "",
+            "<violations>",
+            critique,
+            "</violations>",
+            "",
+            "Fix every violation and call write_artifact again with the same path.",
+            "Do not argue with the review and do not explain yourself - rewrite the artifact.",
+        ].join("\n");
+    }
+    return [
+        `You are executing step '${step.name}' of the skill '${skill.name}'.`,
+        "",
+        // A skill runs in its own session and has never seen the conversation that led here.
+        // Without this it re-asks what the person has already said, which reads as the skill
+        // not listening.
+        context
+            ? `<what the user has already said>\n${context}\n</what the user has already said>\n\nTake this as given. Do not ask again for anything it already answers; confirm it in one line and move to what is still unknown.\n`
+            : "",
+        step.instructions,
+        "",
+        // What the step names by path - its references, another skill to follow - is found from here.
+        `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.
+        step.gate
+            ? `When you are done, call write_artifact with path "${artifactPath(step)}" holding the record the review will be checked against.`
+            : "",
+    ]
+        .filter((part) => part !== "")
+        .join("\n");
+}
+export function compileSkill(opts) {
+    const { skill, report } = opts;
+    const graph = new StateGraph(GenomeState);
+    // The step being resumed is told it was interrupted - once. A retry after its gate is an
+    // ordinary retry.
+    let resuming = opts.startAt;
+    skill.steps.forEach((step, index) => {
+        const nextNode = index + 1 < skill.steps.length ? stepNode(skill.steps[index + 1].name) : END;
+        graph.addNode(stepNode(step.name), async (state) => {
+            opts.onStepStart?.(step.name, state);
+            const attempt = (state.attempts[step.name] ?? 0) + 1;
+            report.step(step.name, attempt);
+            // Only the first step needs it: the executor keeps one session across every step,
+            // so it is already in the history by the time the second runs.
+            const context = index === 0 ? opts.context : undefined;
+            await opts.beforeStep?.(step.name);
+            const note = state.critique ? undefined : opts.stepNote?.(step.name);
+            const prompt = [
+                resuming === step.name && !state.critique ? resumePrompt(step) : stepPrompt(skill, step, state.critique, context),
+                note,
+            ]
+                .filter((part) => part !== undefined && part !== "")
+                .join("\n\n");
+            resuming = undefined;
+            let reply = await ask(opts.executor, prompt);
+            // A question in the reply reaches no one - the person sees only what ask_user asks - and the step ends with the
+            // turn: back to the work, so a step is not left half done on a question nobody answers.
+            for (let nudges = 0; nudges < QUESTION_NUDGES && endsOnQuestion(reply); nudges += 1) {
+                reply = await ask(opts.executor, unansweredQuestionPrompt(skill, step));
+            }
+            let artifact = "";
+            try {
+                artifact = readFileSync(join(opts.runDir, artifactPath(step)), "utf8").trim();
+            }
+            catch {
+                // Left empty on purpose: the gate treats a missing artifact as a failure.
+            }
+            if (artifact)
+                report.artifact(artifactPath(step), artifact);
+            return {
+                artifacts: { [step.name]: artifact },
+                attempts: { [step.name]: attempt },
+                critique: "",
+            };
+        });
+        if (!step.gate) {
+            graph.addEdge(stepNode(step.name), nextNode);
+            return;
+        }
+        const review = step.gate.review;
+        const rubric = readRubric(skill, review);
+        graph.addNode(gateNode(step.name), async (state) => {
+            const artifact = state.artifacts[step.name] ?? "";
+            // A reviewer that has been reading along all phase gets the last word before the
+            // judges are spent: it has seen every spec as it landed, and anything it is still
+            // unhappy about is a violation the step has to fix whatever the record says.
+            const live = opts.liveReviewers?.get(step.name);
+            if (live !== undefined) {
+                const settled = await live.settle();
+                report.liveReview?.(step.name, live.passes(), settled.findings.length);
+                if (!settled.clean) {
+                    const attempts = state.attempts[step.name] ?? 1;
+                    const decision = review.onFail === "abort"
+                        ? "abort"
+                        : review.onFail === "retry" && attempts <= review.maxRetries
+                            ? "retry"
+                            : "escalate";
+                    const critique = describeFindings(settled.findings);
+                    report.outcome(step.name, decision, critique);
+                    return { decision, critique };
+                }
+            }
+            let outcome;
+            if (!artifact) {
+                // No judges needed - the step did not produce the thing it was asked to produce.
+                outcome = {
+                    passed: false,
+                    results: [],
+                    critique: `- You never called write_artifact with path "${artifactPath(step)}", so there is nothing to review.`,
+                };
+                report.gate(step.name, 0);
+            }
+            else {
+                report.gate(step.name, review.judges);
+                outcome = await runGate({
+                    cwd: opts.cwd,
+                    review,
+                    defaultModel: opts.model,
+                    rubric,
+                    artifactPath: artifactPath(step),
+                    artifact,
+                    executor: opts.executor,
+                    onJudgeStart: () => { },
+                });
+                for (const r of outcome.results) {
+                    report.judge(r.index, r.model, r.verdict?.verdict ?? "no verdict", r.verdict?.violations.length ?? 0);
+                }
+            }
+            const attempts = state.attempts[step.name] ?? 1;
+            const retriesLeft = attempts <= review.maxRetries;
+            let decision;
+            if (outcome.passed)
+                decision = "advance";
+            else if (review.onFail === "abort")
+                decision = "abort";
+            else if (review.onFail === "retry" && retriesLeft)
+                decision = "retry";
+            else
+                decision = "escalate";
+            report.outcome(step.name, decision, outcome.critique);
+            // The critique is for this step's retry; the next step starts fresh.
+            return { decision, critique: decision === "advance" ? "" : outcome.critique };
+        });
+        graph.addNode(escalateNode(step.name), async (state) => {
+            const answer = interrupt({
+                step: step.name,
+                artifact: state.artifacts[step.name] ?? "",
+                critique: state.critique,
+                question: `Review gate on '${step.name}' could not be satisfied. Accept the artifact anyway?`,
+            });
+            const approved = typeof answer === "boolean" ? answer : Boolean(answer?.approved);
+            // Accepted, the rejection stays with this step - the next one must not take it for its own.
+            return approved ? { decision: "advance", critique: "" } : { decision: "abort" };
+        });
+        graph.addEdge(stepNode(step.name), gateNode(step.name));
+        const route = (state) => {
+            if (state.decision === "advance")
+                return nextNode;
+            if (state.decision === "retry")
+                return stepNode(step.name);
+            if (state.decision === "escalate")
+                return escalateNode(step.name);
+            return END;
+        };
+        graph.addConditionalEdges(gateNode(step.name), route, [
+            nextNode,
+            stepNode(step.name),
+            escalateNode(step.name),
+            END,
+        ]);
+        graph.addConditionalEdges(escalateNode(step.name), (state) => (state.decision === "advance" ? nextNode : END), [nextNode, END]);
+    });
+    // Every step is a possible entry point, so none is unreachable when a resumed run starts
+    // part-way through; which one is taken is decided here.
+    const first = opts.startAt !== undefined && skill.steps.some((s) => s.name === opts.startAt) ? opts.startAt : skill.steps[0].name;
+    graph.addConditionalEdges(START, () => stepNode(first), skill.steps.map((s) => stepNode(s.name)));
+    return graph;
+}

package/dist/identity.js

@@ -0,0 +1,35 @@
+/** 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 = [
+    "<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",
+    "change at a time - with agents that write the code and tests, while you decide what runs next and when the work is",
+    "done - record what each piece was regenerated from, and prove it against conformance tests written from the ***plain",
+    "alone. When the code goes bad, you regenerate it from the ***plain. You are named after Turritopsis dohrnii, the",
+    "immortal jellyfish: when it is damaged or ages, it turns back into its young self and regenerates its whole body",
+    "from the same genes. Regenerative software works the same way - the ***plain is the genes, and code that has",
+    "gone bad is regenerated from it, whole, rather than patched. Say it as that likeness, not as a fact about a",
+    "jellyfish.",
+    "",
+    "Asked who or what you are, say it in those words: you are turri, a coding agent with the power of regenerative",
+    "software - you help them write ***plain and regenerate the code from it. Not an assistant, and not a helper with",
+    "specifications: ***plain is the language they write, and naming it is the point. Your replies are Markdown, where",
+    "three asterisks start bold italics: write the name escaped, \\*\\*\\*plain, so it shows as ***plain.",
+    "",
+    "Speak as turri, in the first person - I, my pulses, my agents - to the person, in whole sentences. Never speak of",
+    "turri in the third person, as if it were someone else, and never tell the person to tell or ask turri something:",
+    "they are talking to turri. What they should ask for, they ask you for, here.",
+    "",
+    "Your words, and the older ones for the same things - a project's AGENTS.md, a skill, notes or the person may use",
+    "either, and they mean the same:",
+    "- 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 (/regen, or 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.",
+    "- 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");