@turri-dev/cli 0.2.0 → 0.2.1-next.47b578c

package/dist/sentinel.js

@@ -1,8 +1,9 @@
-import { appendFileSync, existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { appendFileSync, existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { load as loadYaml } from "js-yaml";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { readProjectConfig } from "./config.js";
+import { readConfigFile, readProjectConfig } from "./config.js";
 import { confinedTools } from "./regenerate/confine.js";
 import { describeSpecConflict } from "./regenerate/stop-report.js";
 import { didNotPass } from "./regenerate/job-panel.js";
@@ -30,9 +31,10 @@ export function sentinelSetting(cwd) {
 }
 /**
  * What the person is asked before the sentinel first opens in a session, under `sentinel: ask`, in one sentence: the pulse
- * that would open it and what it does - so a tab that starts working on its own is not a surprise - and whether to start it.
+ * - or the host's check - that would open it and what it does - so a tab that starts working on its own is not a surprise
+ * - and whether to start it.
  */
-export function sentinelStartNotice(job, cwd) {
+export function sentinelStartNotice(about, cwd) {
     let released = false;
     try {
         released = readProjectConfig(cwd).releaseAfterPulse === true;
@@ -40,10 +42,28 @@ export function sentinelStartNotice(job, cwd) {
     catch {
         /* a config that cannot be read releases nothing */
     }
+    const what = `a background tab that reviews each finished pulse${released ? " and tries to use what was released" : ""}`;
+    if (!("kind" in about)) {
+        return {
+            kind: "sentinel-start",
+            severity: "info",
+            summary: `Checking ${about.funcIds.join(", ")} of ${about.module} needs the sentinel, ${what} - start it?`,
+            evidence: [],
+            actions: [
+                { label: SENTINEL_START.start, task: "The sentinel is started for this session: this check, and each pulse after it, go to it." },
+                { label: SENTINEL_START.always, task: "The sentinel is started, and sentinel: true written to config.turri.yaml: it opens without asking from now on." },
+                { label: SENTINEL_START.notNow, task: "No sentinel this session: the check is not done. turri asks again next time." },
+                { label: SENTINEL_START.never, task: "sentinel: false written to config.turri.yaml: no sentinel, and no asking." },
+            ],
+            module: about.module,
+            check: about.id,
+        };
+    }
+    const job = about;
     return {
         kind: "sentinel-start",
         severity: "info",
-        summary: `${pulseName(job)} finished - start the sentinel, a background tab that reviews each finished pulse${released ? " and tries to use what was released" : ""}?`,
+        summary: `${pulseName(job)} finished - start the sentinel, ${what}?`,
         evidence: [],
         actions: [
             { label: SENTINEL_START.start, task: "The sentinel is started for this session: this pulse and each after it go to it." },
@@ -112,9 +132,19 @@ export function pulseEndsBlock(sentinel) {
  * What the chat the person is in is told of a pulse that landed, with the sentinel on: that it landed, what the sentinel
  * does with it - and to tell the person so, and do nothing else about it.
  */
-export function landedNote(job, released) {
+export function landedNote(job, released, options = {}) {
     const wasReleased = job.details?.released === true;
     const where = released.map((item) => `${item.name} at ${item.url ?? item.command}`).join(", ");
+    // The host showed the person the pulse's end itself: what happened, for when they ask - nobody is told anything now.
+    if (options.shown === true) {
+        return [
+            `Pulse ${job.id} - ${pulseName(job)} - landed, after ${formatDuration(job)}.`,
+            "",
+            (job.report ?? "").trim(),
+            "",
+            `The sentinel - a chat of my own beside this one - checked it after it landed${wasReleased ? `, and tested what was released${where !== "" ? ` (${where})` : ""}` : ""}; the person was shown that it landed. The pulse is the sentinel's: nothing is to be tested, released, opened or run for it here.`,
+        ].join("\n");
+    }
     return [
         `Pulse ${job.id} - ${pulseName(job)} - landed, after ${formatDuration(job)}.`,
         "",
@@ -137,8 +167,9 @@ export function sentinelPrompt(cwd, options = {}) {
     return [
         "<sentinel>",
         "You are turri's sentinel: a chat of turri's own, beside the chats the person talks to while they build their software",
-        "with turri. Every pulse that finishes comes to you, each in a conversation of its own: this one is for the pulse in",
-        "the message turri writes first - what the pulse was, how it ended,",
+        "with turri. Every pulse that finishes comes to you, each in a conversation of its own - and functional specs the person",
+        "asks you to check. This conversation is for the pulse, or the check, in the message turri writes first. For a pulse:",
+        "what it was, how it ended,",
         ...(surface === ""
             ? ["its ***plain diff, its log, and what was released. The person does not watch you: they are in another chat, and", "hear from you only through notify_person."]
             : [
@@ -153,10 +184,18 @@ export function sentinelPrompt(cwd, options = {}) {
         "   where the message says. How far you test is yours to judge, from what the pulse changed and what the ***plain says",
         "   it should do: that it came up, answers, and does what its ***plain diff says it now does.",
         "3. When something is wrong - the pulse failed or stopped, it did not pass, the release did not come up, the software",
-        "   does not do what its ***plain says - find out why, and call notify_person once: what is wrong, what shows it,",
-        "   and what the person can do about it, each a task the agent of their chat can carry out once they accept it - a",
-        "   change to the ***plain, a setting, a credential to provide, a pulse to regenerate again. Be exact: the task is",
-        "   all that agent is given.",
+        "   does not do what its ***plain says - find out why. Then:",
+        "   - When it is the project's tooling - a testing script, or where config.turri.yaml says the scripts are and which",
+        "     toolchain folders the agents may read (toolchains:) - fix it yourself, with edit: a script calling python3 where",
+        "     this machine has python of the version the ***plain names, a path that moved, a flag the tool's version does not",
+        "     take. Check what you rely on in your shell first (`command -v python`, `python --version`). Then call resume for",
+        "     the module, so the work runs again with the fix - and notify_person once, fixed: true, severity info, no actions:",
+        "     what you changed and why, the lines before and after in the evidence.",
+        "   - Anything else, call notify_person once: what is wrong, what shows it, and what the person can do about it, each",
+        "     a task the agent of their chat can carry out once they accept it - a change to the ***plain, a credential to",
+        "     provide, a pulse to regenerate again. Be exact: the task is all that agent is given. What the machine lacks - a",
+        "     toolchain, a tool, a system library - and any setting of the machine's or the person's shell: say exactly what",
+        "     the person runs themselves (`brew install node`), and make the action resuming once they have.",
         "   When it is a gap in the ***plain the build settled with an assumption - something the person may reasonably leave",
         "   as it is - say so with ignorable: the gap in the summary, what the build does in the evidence. Never for",
         "   something broken, a pulse that went wrong, or a release that did not come up.",
@@ -164,9 +203,16 @@ export function sentinelPrompt(cwd, options = {}) {
         "5. Last, call conclude once for it - holds or wrong, and in a line or two what you checked and what you found:",
         "   the chat the person is in is told, whether all is well or not. Then say the same here, in a line or two.",
         "",
-        "You change nothing. Your file tools read the whole project and write nothing; your shell runs with the project",
-        "read only. You never regenerate, steer, release or change ***plain yourself, and never ask the person questions -",
-        "a notice is how you reach them.",
+        "For a check: the person picked functional specs of a module for you to test in its release, which runs where the",
+        "message says. Test those - what each says and its scenarios - not the module's other functional specs. Notify the",
+        "person of what does not do what its ***plain says, as for a pulse, and call conclude once for the check, by its id.",
+        "",
+        "You fix the project's tooling and nothing else. Your file tools read the whole project; write and edit reach only the",
+        "testing scripts and config.turri.yaml - and in it only where the scripts are, and toolchains:. Your shell runs with",
+        "the project read only. You never change ***plain - it is the person's intent, never yours to fix - and never steer,",
+        "release, or regenerate but by resume after a fix of yours. You install nothing on this machine and change none of",
+        "its settings, nor the person's shell - under no circumstances: that is always the person's, said in a notice. You",
+        "never ask the person questions - a notice is how you reach them.",
         "",
         "The person can talk to you here. When they tell you how to check - what to test, what to leave alone, where things",
         "run - keep it with keep_guidance, in their words, so it holds from now on: this conversation ends with its pulse,",
@@ -222,12 +268,7 @@ export function sentinelBrief(job, context) {
         lines.push("", `Its log: ${job.logFile}`);
     const released = job.details?.released === true;
     if (released) {
-        lines.push("", "It was released, as its last stage (release-after-pulse). What runs now:");
-        if (context.released.length === 0)
-            lines.push("  nothing is running for it: the release did not leave anything running.");
-        for (const item of context.released)
-            lines.push(`  ${item.name}: ${item.url ?? item.command} - in ${item.dir}, its output in ${item.log}`);
-        lines.push("Test it.");
+        lines.push("", "It was released, as its last stage (release-after-pulse). What runs now:", ...whatRuns(context.released), "Test it.");
     }
     else if (job.status === "succeeded" && !didNotPass(job)) {
         lines.push("", context.releaseAfterPulse ? "Nothing was released after it." : "release-after-pulse is off: nothing was released, and you test nothing running - check the pulse alone.");
@@ -236,22 +277,144 @@ export function sentinelBrief(job, context) {
         lines.push("", "It stopped on two functional specs that contradict each other: turri has put that to the person itself. Notify no one about it.");
     }
     else if (wentWrong(job)) {
-        lines.push("", "It went wrong: find out why, and notify the person. What the chat would have been told to do about it - each step of it", "that changes or installs something is a task for a notice's action, not yours:", context.reaction);
+        lines.push("", "It went wrong: find out why. A testing script, or where the config says the scripts are, is yours to fix - then resume", "the module, and tell the person what you changed. Anything else, notify the person. What the chat would have been told", "to do about it - each step of it that is not a fix to the tooling is a task for a notice's action, not yours, and an", "install is never anyone's but the person's:", context.reaction);
     }
     lines.push("", `When you are done with it, call conclude for ${job.id} - whether all is well or not.`);
     return lines.join("\n");
 }
+/** What runs of a release, a line each: where, from where, its output - or that nothing was left running. */
+function whatRuns(released) {
+    if (released.length === 0)
+        return ["  nothing is running for it: the release did not leave anything running."];
+    return released.map((item) => `  ${item.name}: ${item.url ?? item.command} - in ${item.dir}, its output in ${item.log}`);
+}
+/**
+ * What the sentinel is told of a host's check: the module and its release - what runs, and where - and the functional
+ * specs to test, with what each says and its scenarios, as turri reads them now.
+ */
+export function sentinelCheckBrief(check, context) {
+    const lines = [
+        `Check ${check.id}: the person asked you to check ${check.funcIds.length === 1 ? "a functional spec" : `${check.funcIds.length} functional specs`} of ${check.module}, in its release.`,
+    ];
+    if (context.focused !== undefined)
+        lines.push(`The person is in the chat "${context.focused}": a notice goes there.`);
+    lines.push("", `${check.module}'s release holds its code and that of every module its requires chain builds on: its last commit${context.commit !== undefined ? `, ${context.commit}` : ""}, which landed whole - never what a pulse is writing now.`, context.releasedNow ? "It was released for this check. What runs now:" : "What runs was released from that commit already, and is left as it is. What runs now:", ...whatRuns(context.released), "", `Test these functional specs of ${check.module} - only these, not its others, though they are in the release too:`);
+    for (const spec of context.specs) {
+        lines.push("", `# ${spec.funcId}`, spec.text);
+        for (const [title, scenarios] of [["Conformance scenarios", spec.conformance], ["Acceptance scenarios", spec.acceptance]]) {
+            if (scenarios.length === 0)
+                continue;
+            lines.push(`${title}:`, ...scenarios.map((scenario) => `- ${scenario.id}: ${scenario.text.replace(/\n+/g, " ")}`));
+        }
+    }
+    lines.push("", "How far you test each is yours to judge, from what it says and its scenarios. When one does not do what its ***plain says, find out why and notify the person, as for a pulse, naming the check.", `When you are done, call conclude for check ${check.id} - whether all is well or not.`);
+    return lines.join("\n");
+}
 // ---------------------------------------------------------------------------------------------
 // Its tools.
-/** The tools the sentinel's agent may call: what reads, its notices and its guidance - and what a host gives it. */
-export const SENTINEL_TOOLS = ["read", "ls", "grep", "find", "bash", "read_output", "ledger", "pulses", "diagnose", "parse", "doctor", "web_search", "web_fetch", "notify_person", "conclude", "keep_guidance"];
 /**
- * Its file tools and shell: the whole project to read and nothing to write - the shell behind the command check, the OS
- * sandbox where one is up, and the audit, with the network open. Its home and temporary folder are its own, in the
- * modules' scratch.
+ * The tools the sentinel's agent may call: what reads, write and edit for the project's tooling alone, resume, its
+ * notices and its guidance - and what a host gives it.
+ */
+export const SENTINEL_TOOLS = ["read", "ls", "grep", "find", "write", "edit", "bash", "read_output", "ledger", "pulses", "diagnose", "parse", "doctor", "web_search", "web_fetch", "resume", "notify_person", "conclude", "keep_guidance"];
+/** A testing script by its name - `run_unittests_python.sh`, `prepare_environment_node.sh` - and a config file of turri's. */
+const SCRIPT_FILE = /^(run_|prepare_environment).*\.(sh|ps1|bat|cmd)$/;
+const CONFIG_FILE_NAME = /^config\.turri(\..+)?\.yaml$/;
+/** The keys of config.turri.yaml the sentinel may change: where the testing scripts are, and the toolchains' folders. */
+export const SENTINEL_CONFIG_KEYS = ["unittests-script", "conformance-tests-script", "prepare-environment-script", "toolchains"];
+/**
+ * The project's tooling, which the sentinel fixes itself: its testing scripts - `test_scripts/`, a `run_*.sh` or
+ * `prepare_environment*.sh` at its root, and each script its config names - and its `config.turri*.yaml` files. In the
+ * project, and in a project one folder down (***plain kept in plain/). Never a .plain file: the ***plain is the person's.
+ */
+export function sentinelTooling(cwd) {
+    const root = resolve(cwd);
+    const projects = [root, ...listDirs(root).filter((dir) => listFiles(dir).some((name) => CONFIG_FILE_NAME.test(name)))];
+    return [
+        ...new Set(projects.flatMap((project) => {
+            const configs = listFiles(project).filter((name) => CONFIG_FILE_NAME.test(name));
+            const named = configs.flatMap((name) => {
+                const config = readConfigFile(join(project, name));
+                return [config.unittestsScript, config.conformanceTestsScript, config.prepareEnvironmentScript].filter((path) => typeof path === "string").map((path) => resolve(project, path));
+            });
+            return [
+                join(project, "test_scripts"),
+                ...listFiles(project).filter((name) => SCRIPT_FILE.test(name)).map((name) => join(project, name)),
+                ...configs.map((name) => join(project, name)),
+                ...named,
+            ];
+        })),
+    ].filter((path) => !path.endsWith(".plain"));
+}
+function listFiles(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+function listDirs(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== MODULES_DIR && entry.name !== "node_modules").map((entry) => join(dir, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Its file tools and shell: the whole project to read, and to write only its tooling (`sentinelTooling`) - in a config
+ * file, only the keys of SENTINEL_CONFIG_KEYS. Its shell runs behind the command check, the OS sandbox where one is up,
+ * and the audit, with the project read only and the network open - and changes nothing of the machine's. Its home and
+ * temporary folder are its own, in the modules' scratch.
  */
 export function sentinelFileTools(cwd) {
-    return confinedTools({ workdir: cwd, read: [cwd], write: [], shellHome: join(cwd, MODULES_DIR, `.${SENTINEL}`) }).tools;
+    const tooling = sentinelTooling(cwd);
+    const { tools } = confinedTools({ workdir: cwd, read: [cwd], write: tooling, shellHome: join(cwd, MODULES_DIR, `.${SENTINEL}`), fixesScripts: true });
+    const shell = confinedTools({ workdir: cwd, read: [cwd], write: [], shellHome: join(cwd, MODULES_DIR, `.${SENTINEL}`) }).tools;
+    return tools.map((tool) => {
+        // Its shell writes nothing in the project: only write and edit reach the tooling.
+        if (tool.name === "bash")
+            return shell.find((each) => each.name === "bash");
+        if (tool.name !== "write" && tool.name !== "edit")
+            return tool;
+        return {
+            ...tool,
+            async execute(toolCallId, params, signal, onUpdate, ctx) {
+                const path = resolve(cwd, String(params.path ?? ""));
+                if (!CONFIG_FILE_NAME.test(basename(path)))
+                    return tool.execute(toolCallId, params, signal, onUpdate, ctx);
+                // A config file: only where the testing scripts are, and the toolchains, may change - anything else is put back.
+                const before = existsSync(path) ? readFileSync(path, "utf8") : undefined;
+                const result = await tool.execute(toolCallId, params, signal, onUpdate, ctx);
+                const changed = changedKeys(before ?? "", existsSync(path) ? readFileSync(path, "utf8") : "").filter((key) => !SENTINEL_CONFIG_KEYS.includes(key.replace(/_/g, "-")));
+                if (changed.length > 0) {
+                    if (before === undefined)
+                        rmSync(path, { force: true });
+                    else
+                        writeFileSync(path, before);
+                    throw new Error(`Put back: in ${basename(path)} the sentinel changes only ${SENTINEL_CONFIG_KEYS.join(", ")} - not ${changed.join(", ")}. A setting of any other kind is the person's: put it to them with notify_person.`);
+                }
+                return result;
+            },
+        };
+    });
+}
+/** The top-level keys whose values differ between two config texts - one that does not parse differing in every key. */
+function changedKeys(before, after) {
+    const parse = (text) => {
+        try {
+            const value = loadYaml(text);
+            return value !== null && typeof value === "object" && !Array.isArray(value) ? value : value === undefined || value === null ? {} : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const [was, now] = [parse(before), parse(after)];
+    if (was === undefined || now === undefined)
+        return ["the file as a whole - it no longer reads as YAML"];
+    return [...new Set([...Object.keys(was), ...Object.keys(now)])].filter((key) => JSON.stringify(was[key]) !== JSON.stringify(now[key]));
 }
 export function notifyTool(notify) {
     return defineTool({
@@ -259,7 +422,8 @@ export function notifyTool(notify) {
         label: "Notify",
         description: "Put what is wrong with a finished pulse to the person, in the chat they are in: what is wrong, what shows it, and what " +
             "they can do about it. Each action is a task the agent of their chat carries out once they accept it. Only when they " +
-            "need to act - never for a pulse that went well.",
+            "need to act - never for a pulse that went well - or, severity info and no actions, to say what you fixed yourself in " +
+            "the testing scripts or their config, and why.",
         parameters: Type.Object({
             severity: Type.Union([Type.Literal("error"), Type.Literal("warning"), Type.Literal("info")], { description: "error: it is broken; warning: it works but not as its ***plain says, or something is missing; info: worth their knowing" }),
             summary: Type.String({ description: "What is wrong, in one line" }),
@@ -270,6 +434,8 @@ export function notifyTool(notify) {
             }), { description: "What can be done, the best first" }),
             module: Type.Optional(Type.String({ description: "The module it is about" })),
             pulse: Type.Optional(Type.String({ description: "The pulse's id" })),
+            check: Type.Optional(Type.String({ description: "The check's id, when it is about a check the person asked for" })),
+            fixed: Type.Optional(Type.Boolean({ description: "true when this says what you fixed yourself in a testing script or its config - severity info, no actions: a note, nothing to answer" })),
             ignorable: Type.Optional(Type.Boolean({
                 description: "true when the person may reasonably leave it as the build has it, for good: chiefly a gap in the ***plain the build settled with an " +
                     "assumption - then say the gap in the summary and what the build does in the evidence (the ***plain does not say what happens to " +
@@ -283,8 +449,10 @@ export function notifyTool(notify) {
                 evidence: params.evidence,
                 actions: params.actions,
                 ...(params.ignorable === true ? { ignorable: true } : {}),
+                ...(params.fixed === true ? { kind: "fixed" } : {}),
                 ...(params.module !== undefined ? { module: params.module } : {}),
                 ...(params.pulse !== undefined ? { job: params.pulse } : {}),
+                ...(params.check !== undefined ? { check: params.check } : {}),
             });
             return {
                 content: [{ type: "text", text: notice !== undefined ? `Put to the person, in the chat they are in (notice ${notice.id}).` : "There is no chat to put it in: say it here." }],
@@ -297,15 +465,19 @@ export function concludeTool(conclude) {
     return defineTool({
         name: "conclude",
         label: "Conclude",
-        description: "Say you are done with a pulse - whether what you checked holds, and in a line or two what you checked and found. The chat " +
-            "the person is in is told, whether all is well or not. Once a pulse, last - after notify_person, when something is wrong.",
+        description: "Say you are done with a pulse - or a check the person asked for - whether what you checked holds, and in a line or two what " +
+            "you checked and found. The chat the person is in is told, whether all is well or not. Once a pulse or check, last - after " +
+            "notify_person, when something is wrong. Name the pulse, or the check.",
         parameters: Type.Object({
-            pulse: Type.String({ description: "The pulse's id" }),
+            pulse: Type.Optional(Type.String({ description: "The pulse's id" })),
+            check: Type.Optional(Type.String({ description: "The check's id, for a check the person asked for - in place of pulse" })),
             verdict: Type.Union([Type.Literal("holds"), Type.Literal("wrong")], { description: "holds: it does what its ***plain says; wrong: it does not, or it went wrong" }),
             summary: Type.String({ description: "What you checked and what you found, in a line or two: \"GET /api/ping answers pong; the new alias route redirects\"" }),
         }),
         async execute(_id, params) {
-            const chat = conclude({ job: params.pulse, verdict: params.verdict, summary: params.summary });
+            if ((params.pulse === undefined) === (params.check === undefined))
+                throw new Error("Name the pulse, or the check - one of them.");
+            const chat = conclude({ ...(params.pulse !== undefined ? { job: params.pulse } : { check: params.check }), verdict: params.verdict, summary: params.summary });
             return {
                 content: [{ type: "text", text: chat !== undefined ? "The chat the person is in is told." : "There is no chat to tell: say it here." }],
                 details: {},
@@ -314,10 +486,27 @@ export function concludeTool(conclude) {
     });
 }
 /** What the chat the person is in is told when the sentinel is done with a pulse: to say so, and do nothing more. */
-export function concludedNote(conclusion) {
-    const about = conclusion.module !== undefined ? `${conclusion.module}${conclusion.pulse !== undefined ? ` pulse ${conclusion.pulse}` : ""}` : `pulse ${conclusion.job}`;
+export function concludedNote(conclusion, options = {}) {
+    const about = conclusion.check !== undefined
+        ? `the check you asked for${conclusion.module !== undefined ? ` of ${conclusion.module}` : ""}`
+        : conclusion.module !== undefined
+            ? `${conclusion.module}${conclusion.pulse !== undefined ? ` pulse ${conclusion.pulse}` : ""}`
+            : `pulse ${conclusion.job}`;
+    if (conclusion.verdict === "unchecked") {
+        if (options.shown === true)
+            return [`The sentinel did not do ${about} (${conclusion.check ?? conclusion.job}).`, conclusion.summary.trim()].join("\n");
+        return [`The sentinel did not do ${about} (${conclusion.check ?? conclusion.job}).`, conclusion.summary.trim(), "", "Tell the person, in a line, that it was not checked and why. Do nothing else about it."].join("\n");
+    }
+    // The host showed the person the conclusion itself: what the sentinel found, for when they ask.
+    if (options.shown === true) {
+        return [
+            `The sentinel is done with ${about} (${conclusion.check ?? conclusion.job}): ${conclusion.verdict === "holds" ? "it holds" : "something is wrong"}.`,
+            conclusion.summary.trim(),
+            ...(conclusion.verdict === "wrong" ? ["", "Its notice in this chat says what is wrong and what can be done; nothing is done about it until the person answers it."] : []),
+        ].join("\n");
+    }
     return [
-        `The sentinel is done with ${about} (${conclusion.job}): ${conclusion.verdict === "holds" ? "it holds" : "something is wrong"}.`,
+        `The sentinel is done with ${about} (${conclusion.check ?? conclusion.job}): ${conclusion.verdict === "holds" ? "it holds" : "something is wrong"}.`,
         conclusion.summary.trim(),
         "",
         conclusion.verdict === "holds"
@@ -325,6 +514,20 @@ export function concludedNote(conclusion) {
             : "Tell the person, in a line, that the sentinel found something wrong, and that its notice in this chat says what and what can be done. Do nothing else about it until they answer the notice.",
     ].join("\n");
 }
+/** Bring a module up again once the sentinel fixed what stopped its pulse: what is left there is regenerated, its scripts run. */
+export function resumeTool(resume) {
+    return defineTool({
+        name: "resume",
+        label: "Resume",
+        description: "Bring a module up again after you fixed what stopped its pulse - a testing script, a toolchains: entry: what is left to " +
+            "regenerate there runs again, its testing scripts with it, as when the person asks for it. Only after a fix of yours, " +
+            "never to try again what nothing was changed for. What it starts comes back to you as a pulse that finished.",
+        parameters: Type.Object({ plain_file: Type.String({ description: "The module's .plain file, from the project's folder: app.plain" }) }),
+        async execute(_id, params) {
+            return { content: [{ type: "text", text: await resume(params.plain_file) }], details: {} };
+        },
+    });
+}
 export function keepGuidanceTool(cwd) {
     return defineTool({
         name: "keep_guidance",

package/dist/setup.d.ts

@@ -35,8 +35,8 @@ export declare function checkSandbox(wall?: Wall, platform?: NodeJS.Platform): C
 export declare function checkProject(project: string, machine?: {
     has?: (command: string) => boolean;
     exists?: (path: string) => boolean;
-    jdk?: () => boolean;
-}): Check[];
+    jdk?: () => boolean | Promise<boolean>;
+}): Promise<Check[]>;
 /**
  * In a project: each model its config names - with the stack chosen, that stack's over it - tried with one short
  * request. A model that answers is ready; one that does not says what the provider said, and what to do about it.
@@ -55,11 +55,32 @@ export interface DoctorOptions {
  * nothing, so a host can show them in its own way; `turri doctor` prints the same.
  */
 export declare function doctor(options?: DoctorOptions): Promise<Check[]>;
+/** The environment pi-claude-code refuses to run with: each points Claude Code at an API key or another backend, not the subscription. */
+export declare const CLAUDE_CODE_CONFLICTS: string[];
+/** What the Claude subscription check looks at - this machine's, or a test's. */
+export interface ClaudeCodeProbe {
+    /** Whether pi has the claude-code provider: its extension, pi-claude-code, installed. */
+    installed(): Promise<boolean>;
+    /** `claude auth status`, as it answers: undefined when there is no claude to run. */
+    status(command: string, env: NodeJS.ProcessEnv): Promise<{
+        loggedIn?: boolean;
+        subscriptionType?: string;
+        authMethod?: string;
+    } | undefined>;
+    /** The executable a command name is, on the PATH - undefined when it is not there. */
+    which(command: string, env: NodeJS.ProcessEnv): string | undefined;
+}
+/**
+ * A Claude subscription through Claude Code, when the project's config names a `claude-code/...` model: everything
+ * pi-claude-code needs, in the order it needs it - its extension installed, Claude Code on the PATH, signed in to a Pro or
+ * Max subscription, and nothing in the environment it refuses. Nothing when no model is a claude-code one.
+ */
+export declare function checkClaudeSubscription(project: string, env?: NodeJS.ProcessEnv, probe?: ClaudeCodeProbe): Promise<Check[]>;
 /**
  * The base folders the project's config names - its own, and each stack's - each there with its files, or not: a codebase
  * that requires nothing starts from one, and its first pulse stops when it is not there. Nothing when none is named.
  */
-export declare function checkBaseFolders(project: string): Check[];
+export declare function checkBaseFolders(project: string): Promise<Check[]>;
 /**
  * The AWS region a project's Bedrock models are called in, when it uses any: turri's, the person's or the profile's - and
  * what is wrong with it, when the models need two, or the person's is not in their geography. Nothing when it uses none.