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

package/README.md

@@ -19,6 +19,7 @@
 
 ```bash
 npm install -g @turri-dev/cli # puts `turri` on your PATH
+turri --version              # the version you installed? if not, see docs/installation.md#an-older-turri-runs
 turri doctor              # checks the machine
 ```
 
@@ -30,7 +31,7 @@ Then start it in your project, signed in to your model providers:
 
 ```bash
 cd ~/my-project
-turri init-config              # asks which vendor you use: Anthropic, OpenAI, Google, Amazon Bedrock, or other
+turri init-config              # asks which vendor you use: Anthropic, OpenAI, Google, Amazon Bedrock, a Claude subscription, or other
 export ANTHROPIC_API_KEY=...   # the key it names - or skip it, and type /login in turri once it has started
 turri
 ```
@@ -42,7 +43,7 @@ harness-model: anthropic/claude-opus-5-5:medium  # you talk to it
 coding-model: anthropic/claude-haiku-5-5:low     # it writes the code
 ```
 
-To skip the question, name the vendor - `anthropic`, `openai`, `google`, `amazon-bedrock` (with `--maker` and `--region`) or `other`:
+To skip the question, name the vendor - `anthropic`, `openai`, `google`, `amazon-bedrock` (with `--maker` and `--region`), `claude-code` - your Claude Pro or Max subscription, through Claude Code ([how](docs/claude-subscription.md)) - or `other`:
 
 ```bash
 turri init-config --vendor anthropic

package/dist/chats.d.ts

@@ -7,7 +7,7 @@ import type { AskUserIO } from "./ask.ts";
 import type { Job, JobRegistry } from "./regenerate/jobs.ts";
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { AdvisorVerdict } from "./regenerate/advisor-runs.ts";
-import { type ChatRole, type Conclusion, type Notice, type NoticeAnswer, type NoticeInput } from "./notice.ts";
+import { type ChatRole, type Conclusion, type Notice, type NoticeAnswer, type NoticeInput, type SentinelCheck } from "./notice.ts";
 /**
  * The chats of a turri session.
  *
@@ -73,6 +73,13 @@ export interface TurriHost {
     onConcluded?(conclusion: Conclusion & {
         chat: string;
     }): void;
+    /**
+     * The host shows the person each pulse that lands and each of the sentinel's conclusions itself - its own
+     * notifications, from onJobChange and onConcluded. With the sentinel on, the chat the person is in is then told of both
+     * without a turn of its own: its agent knows what landed and what the sentinel found when the person asks, and does
+     * not say it again in the conversation. Unset, it says both, as in the terminal.
+     */
+    pulseEndsShown?: boolean;
     /** What the sentinel puts to the person - and, `kind: "sentinel-start"`, whether to start it: the host draws it in the chat it names, and answers it with `answer`. */
     onNotice?(notice: Notice): void;
     /** A notice is over - answered, dismissed, or superseded by a newer one about its module: the host takes its card down. */
@@ -103,6 +110,14 @@ export interface ChatInstance {
         asked?: string;
         focused?: string;
     }): Promise<void>;
+    /**
+     * The sentinel's: functional specs a host asked it to check - the module released first, unless what runs is its last
+     * commit, then its agent told, in a conversation of its own for the check. Why not, when the release failed: then its
+     * agent is told nothing.
+     */
+    briefCheck(check: SentinelCheck, context: {
+        focused?: string;
+    }): Promise<string | undefined>;
     /** A notice put in the chat: drawn, and - in the terminal - put to the person once the chat is idle. */
     notice(notice: Notice): void;
     /** A notice is over: its dialog closed, if it is open. */
@@ -219,8 +234,20 @@ export interface TurriCore {
     sentinelOn(): boolean;
     /** A notice put to the person, in the chat they look at - the sentinel's, or turri's own. Undefined: no chat to put it in. */
     notice(input: NoticeInput): Notice | undefined;
-    /** The sentinel done with a pulse: told to the chat the person looks at. Undefined: no chat to tell. */
+    /** The sentinel done with a pulse or a check: told to the chat the person looks at. Undefined: no chat to tell. */
     concluded(conclusion: Conclusion): string | undefined;
+    /**
+     * A host's check for the sentinel: refused with the sentinel off; else `prepare` finds its module and functional specs
+     * good (sentinel-check.ts), and it is queued with the pulses - under `sentinel: ask`, held while the person is asked
+     * whether to start it.
+     */
+    check(prepare: () => SentinelCheck | {
+        refused: string;
+    }): {
+        check: string;
+    } | {
+        refused: string;
+    };
     /** The test advisor's verdict, for the chat the person looks at - held until there is one. Undefined: no chat to hand it to yet. */
     advised(verdict: AdvisorVerdict): string | undefined;
     /** The notices put to the person and not yet answered. */
@@ -252,8 +279,8 @@ export interface CoreOptions {
     dialogs?: (chat: string) => AskUserIO | undefined;
     /** Whether the project wants a sentinel - read as each pulse finishes: on, off, or ask the person first. Unset: none. */
     sentinel?: () => SentinelSetting;
-    /** Under `sentinel: ask`: what the person is asked before the sentinel first opens, about the pulse that would open it. */
-    sentinelStart?: (job: Job) => NoticeInput;
+    /** Under `sentinel: ask`: what the person is asked before the sentinel first opens, about the pulse - or the check - that would open it. */
+    sentinelStart?: (about: Job | SentinelCheck) => NoticeInput;
     /** The person chose for the project, asked whether to start the sentinel: `sentinel:` written. */
     setSentinel?: (on: boolean) => void;
     /** The person ignored a notice for good: kept in the sentinel's guidance, for every conversation after. */

package/dist/chats.js

@@ -91,11 +91,13 @@ export function createChats(options) {
     let notices = [];
     /** What the sentinel put to the person, and turri itself, this session: open until answered or superseded. */
     const open = [];
-    /** The pulse the sentinel's conversation is on, from its brief until its agent is done: a newer one of the same module replaces a check of one that went well. */
+    /** The work the sentinel's conversation is on, from its brief until its agent is done: a newer pulse of the same module replaces a check of one that went well. */
     let checking;
-    /** Pulses that finished while the sentinel was at work: each checked in turn, in a conversation of its own. */
+    /** Pulses that finished, and checks asked for, while the sentinel was at work: each taken in turn, in a conversation of its own. */
     const waiting = [];
-    /** What the sentinel is given is given one pulse at a time: its conversations made, and its pulses put to them, in order. */
+    /** The checks hosts asked for this session, by id: what a notice or a conclusion about one is about. */
+    const checks = new Map();
+    /** What the sentinel is given is given one at a time: its conversations made, and its pulses and checks put to them, in order. */
     let sentinelWork = Promise.resolve();
     /**
      * Under `sentinel: ask`, whether the person said to start the sentinel this session: asked - the notice `asking` open,
@@ -188,7 +190,7 @@ export function createChats(options) {
                 // Done with its pulse - or with what the person said to it: the next pulse waiting, in a conversation of its own.
                 if (chat.role === SENTINEL && event.willRetry !== true) {
                     checking = undefined;
-                    toSentinel(() => nextPulse(chat));
+                    toSentinel(() => nextWork(chat));
                 }
             }
             else if (event.type === "session_info_changed") {
@@ -277,7 +279,10 @@ export function createChats(options) {
             // Closed, the sentinel is let go with what it had to check: the next pulse that finishes opens it again.
             if (chat.role === SENTINEL) {
                 checking = undefined;
-                waiting.length = 0;
+                // A check a host asked for ends all the same: it is told it was not done.
+                for (const work of waiting.splice(0))
+                    if ("check" in work)
+                        unchecked(work.check, "the sentinel was closed before it got to it");
             }
             // The question whether to start the sentinel was in it: put again in the chat the person looks at now.
             if (asking?.chat === id)
@@ -384,7 +389,7 @@ export function createChats(options) {
                 settleStart(setting() === true ? "given" : "declined", "superseded");
             if (core.sentinelOn()) {
                 if (consent === "asking" || (setting() === "ask" && consent === "unasked" && sentinelChat() === undefined && askToStart(job))) {
-                    held.push(job);
+                    held.push({ pulse: job });
                     changed();
                     return;
                 }
@@ -393,6 +398,30 @@ export function createChats(options) {
             }
             toAsker(job);
         },
+        check(prepare) {
+            if (driver === undefined)
+                return { refused: "There is nowhere to open the sentinel in this session." };
+            // The question was settled in config.turri.yaml while it was open: what it held goes as the file now says.
+            if (consent === "asking" && setting() !== "ask")
+                settleStart(setting() === true ? "given" : "declined", "superseded");
+            const now = setting();
+            if (now === false)
+                return { refused: "The sentinel is off for this project (sentinel: false): nothing checks the functional specs. Turn it on with sentinel: true in config.turri.yaml." };
+            if (!wantsSentinel())
+                return { refused: "The sentinel was not started this session - the person said not now when asked: nothing checks the functional specs until turri starts again, or sentinel: true is set." };
+            const check = prepare();
+            if ("refused" in check)
+                return check;
+            checks.set(check.id, check);
+            record({ kind: "sentinel.asked", check: check.id, module: check.module, funcIds: check.funcIds }, { project: cwd });
+            if (consent === "asking" || (now === "ask" && consent === "unasked" && sentinelChat() === undefined && askToStart(check))) {
+                held.push({ check });
+                changed();
+                return { check: check.id };
+            }
+            sentinelChecks(check);
+            return { check: check.id };
+        },
         jobsChanged() {
             for (const chat of chats) {
                 try {
@@ -404,18 +433,22 @@ export function createChats(options) {
             }
         },
         notice(input) {
+            // A check's notice is about its module.
+            const about = input.check !== undefined ? checks.get(input.check) : undefined;
+            if (about !== undefined && input.module === undefined)
+                input = { ...input, module: about.module };
             const asked = chats.find((chat) => chat.id === (input.job !== undefined ? jobs.get(input.job)?.chat : undefined));
             const target = personFacing(asked);
             if (target === undefined)
                 return undefined;
-            // One notice open a module: a newer one makes the older one's call to action stale.
-            if (input.module !== undefined) {
+            // One notice open a module: a newer one makes the older one's call to action stale. A note of a fix asks nothing.
+            if (input.module !== undefined && input.kind !== "fixed") {
                 for (const older of open.filter((notice) => notice.state === "open" && notice.module === input.module))
                     over(older, "superseded");
             }
             // Only the sentinel's own may be ignored: never the question whether to start it.
             const { ignorable, ...rest } = input;
-            const notice = newNotice(ignorable === true && input.kind !== "sentinel-start" ? input : rest, target.id);
+            const notice = newNotice(ignorable === true && input.kind === undefined ? input : rest, target.id);
             open.push(notice);
             if (target.id !== shownId)
                 target.unread = true;
@@ -437,16 +470,17 @@ export function createChats(options) {
         },
         notices: () => open.filter((notice) => notice.state === "open"),
         concluded(conclusion) {
-            const job = jobs.get(conclusion.job);
+            const job = conclusion.job !== undefined ? jobs.get(conclusion.job) : undefined;
+            const check = conclusion.check !== undefined ? checks.get(conclusion.check) : undefined;
             const target = personFacing(chats.find((chat) => chat.id === job?.chat));
             if (target === undefined)
                 return undefined;
-            const module = conclusion.module ?? job?.module;
+            const module = conclusion.module ?? job?.module ?? check?.module;
             const pulse = conclusion.pulse ?? job?.pulse;
             const told = { ...conclusion, ...(module !== undefined ? { module } : {}), ...(pulse !== undefined ? { pulse } : {}) };
             if (target.id !== shownId)
                 target.unread = true;
-            inChat(target.scope, () => record({ kind: "sentinel.concluded", verdict: told.verdict, ...(module !== undefined ? { module } : {}) }, { project: cwd, job: told.job }));
+            inChat(target.scope, () => record({ kind: "sentinel.concluded", verdict: told.verdict, ...(module !== undefined ? { module } : {}), ...(told.check !== undefined ? { check: told.check } : {}) }, { project: cwd, ...(told.job !== undefined ? { job: told.job } : {}) }));
             try {
                 target.instance?.concluded(told);
             }
@@ -577,10 +611,10 @@ export function createChats(options) {
      * Under `sentinel: ask`, the first pulse that would open the sentinel this session: the person asked whether to start it,
      * in the chat they look at. False when there is nothing to ask with, or no chat to ask in: the sentinel opens as asked.
      */
-    function askToStart(job) {
+    function askToStart(about) {
         let input;
         try {
-            input = options.sentinelStart?.(job);
+            input = options.sentinelStart?.(about);
         }
         catch {
             input = undefined;
@@ -599,7 +633,8 @@ export function createChats(options) {
         over(question, "superseded");
         asking = undefined;
         consent = "unasked";
-        if (!askToStart(held[0]))
+        const first = held[0];
+        if (!askToStart("pulse" in first ? first.pulse : first.check))
             settleStart("declined", "superseded");
     }
     /** The person answered whether to start the sentinel: written to the project, when they chose for it, and what was held let go. */
@@ -629,11 +664,17 @@ export function createChats(options) {
         asking = undefined;
         if (question !== undefined && question.state === "open")
             over(question, state);
-        for (const job of held.splice(0)) {
-            if (core.sentinelOn())
-                sentinelFinished(job);
+        for (const work of held.splice(0)) {
+            if ("check" in work) {
+                if (core.sentinelOn())
+                    sentinelChecks(work.check);
+                else
+                    unchecked(work.check, "the person did not start the sentinel");
+            }
+            else if (core.sentinelOn())
+                sentinelFinished(work.pulse);
             else
-                toAsker(job);
+                toAsker(work.pulse);
         }
         changed();
     }
@@ -658,24 +699,41 @@ export function createChats(options) {
         }
         changed();
         toSentinel(async () => {
-            let sentinel = sentinelChat();
-            if (sentinel === undefined) {
-                try {
-                    await core.open({ hidden: true, role: SENTINEL });
-                    sentinel = sentinelChat();
-                }
-                catch (error) {
-                    // No room for it, or nowhere to open it: the pulse is told as it is without one.
-                    core.notify(`The sentinel could not be opened: ${error instanceof Error ? error.message : String(error)}`, "warning");
-                    (asked ?? where)?.instance?.announce(job);
-                    return;
-                }
-            }
-            if (sentinel?.instance === undefined)
-                return;
-            await takePulse(sentinel, job);
+            // No room for it, or nowhere to open it: the pulse is told as it is without one.
+            const sentinel = await openSentinel(() => (asked ?? where)?.instance?.announce(job));
+            if (sentinel !== undefined)
+                await takeWork(sentinel, { pulse: job });
         });
     }
+    /** A check a host asked for, for the sentinel - opened in the background when it is not open - in its turn. */
+    function sentinelChecks(check) {
+        toSentinel(async () => {
+            const sentinel = await openSentinel((why) => unchecked(check, `the sentinel could not be opened: ${why}`));
+            if (sentinel !== undefined)
+                await takeWork(sentinel, { check });
+        });
+    }
+    /** The sentinel's chat, opened hidden when it is not open - none, and `failed` told why, when it cannot be. */
+    async function openSentinel(failed) {
+        let sentinel = sentinelChat();
+        if (sentinel === undefined) {
+            try {
+                await core.open({ hidden: true, role: SENTINEL });
+                sentinel = sentinelChat();
+            }
+            catch (error) {
+                const why = error instanceof Error ? error.message : String(error);
+                core.notify(`The sentinel could not be opened: ${why}`, "warning");
+                failed(why);
+                return undefined;
+            }
+        }
+        return sentinel?.instance !== undefined ? sentinel : undefined;
+    }
+    /** A check that will not be done, told as a conclusion of turri's own - the host waits for one. */
+    function unchecked(check, why) {
+        core.concluded({ check: check.id, module: check.module, verdict: "unchecked", summary: `Not checked: ${why}.` });
+    }
     /** The sentinel's work, after what it was given before. */
     function toSentinel(work) {
         sentinelWork = sentinelWork.then(work).catch((error) => {
@@ -685,36 +743,72 @@ export function createChats(options) {
     /** Whether the sentinel is at work: on a pulse - its turn starts as it is told of one - or on what the person said to it. */
     const sentinelBusy = (sentinel) => sentinel.session?.isStreaming === true;
     /**
-     * A finished pulse, for the sentinel: checked now when it is free. Busy, a newer pulse of a module replaces a check of
-     * the module's last pulse that went well - and a pulse of it that went well and waits - and one that went wrong is
-     * looked into to its end; the rest wait their turn.
+     * A finished pulse or a host's check, for the sentinel: taken now when it is free. Busy, a newer pulse of a module
+     * replaces a check of the module's last pulse that went well - and a pulse of it that went well and waits - and one that
+     * went wrong is looked into to its end; the rest, checks among them, wait their turn.
      */
-    function takePulse(sentinel, job) {
+    function takeWork(sentinel, work) {
         if (!sentinelBusy(sentinel))
-            return check(sentinel, job);
-        const sameModule = (other) => job.module !== undefined && other.module === job.module;
-        if (checking !== undefined && !checking.wrong && sameModule(checking.job))
-            return check(sentinel, job, checking.job);
-        const older = waiting.findIndex((other) => sameModule(other) && !wentWrong(other));
+            return begin(sentinel, work);
+        if (!("pulse" in work)) {
+            waiting.push(work);
+            return;
+        }
+        const job = work.pulse;
+        const sameModule = (other) => job.module !== undefined && "pulse" in other && other.pulse.module === job.module;
+        if (checking !== undefined && !checking.wrong && sameModule(checking.work) && "pulse" in checking.work)
+            return check(sentinel, job, checking.work.pulse);
+        const older = waiting.findIndex((other) => sameModule(other) && "pulse" in other && !wentWrong(other.pulse));
         if (older !== -1)
-            waiting.splice(older, 1, job);
+            waiting.splice(older, 1, work);
         else
-            waiting.push(job);
+            waiting.push(work);
     }
-    /** The sentinel free again: the next pulse that waits, checked. */
-    function nextPulse(sentinel) {
+    /** The sentinel free again: the next pulse or check that waits, taken. */
+    function nextWork(sentinel) {
         if (!chats.includes(sentinel) || sentinelBusy(sentinel))
             return;
-        const job = waiting.shift();
-        if (job !== undefined)
-            return check(sentinel, job);
+        const work = waiting.shift();
+        if (work !== undefined)
+            return begin(sentinel, work);
+    }
+    function begin(sentinel, work) {
+        return "pulse" in work ? check(sentinel, work.pulse) : checkSpecs(sentinel, work.check);
+    }
+    /**
+     * The sentinel on a host's check, from scratch, as on a pulse: a conversation of its own, the module released first
+     * unless what runs is its last commit. A release that fails ends the check - a conclusion of its own - and the next
+     * waiting is taken.
+     */
+    async function checkSpecs(sentinel, check) {
+        checking = { work: { check }, wrong: false };
+        inChat(sentinel.scope, () => record({ kind: "sentinel.checking", module: check.module, check: check.id }, { project: cwd }));
+        const session = sentinel.session;
+        if (session !== undefined && (session.messages.length > 0 || session.isStreaming))
+            await freshConversation(sentinel);
+        if (sentinel.id !== shownId)
+            sentinel.unread = true;
+        const where = personFacing();
+        let why;
+        try {
+            why = await sentinel.instance.briefCheck(check, where !== undefined ? { focused: titleFor(where) } : {});
+        }
+        catch (error) {
+            why = error instanceof Error ? error.message : String(error);
+        }
+        changed();
+        if (why === undefined)
+            return;
+        checking = undefined;
+        core.concluded({ check: check.id, module: check.module, verdict: "wrong", summary: `Not tested: ${check.module} could not be released - ${why}` });
+        await nextWork(sentinel);
     }
     /**
      * The sentinel on a pulse, from scratch: a conversation of its own - its prompt, the project's guidance and this
      * pulse's brief, nothing of the pulses before it - in place of the one it had, stopped when it was on `replacing`.
      */
     async function check(sentinel, job, replacing) {
-        checking = { job, wrong: wentWrong(job) };
+        checking = { work: { pulse: job }, wrong: wentWrong(job) };
         const module = job.module;
         inChat(sentinel.scope, () => record({ kind: "sentinel.checking", ...(module !== undefined ? { module } : {}), ...(replacing !== undefined ? { replaced: replacing.id } : {}) }, { project: cwd, job: job.id }));
         const session = sentinel.session;

package/dist/cli.js

@@ -142,9 +142,11 @@ if (command === "-h" || command === "--help") {
     console.log(USAGE);
     process.exit(0);
 }
-// turri's version, not pi's alone: pi's --version would answer for it.
+// turri's version, not pi's alone: pi's --version would answer for it - and where this turri is, the newest on npm,
+// every turri on the PATH, and what to do when the one that runs is not the newest (turri-versions.ts).
 if (command === "-v" || command === "--version") {
-    console.log(versionLine());
+    const { describeVersion } = await import("./turri-versions.js");
+    console.log(await describeVersion(versionLine()));
     process.exit(0);
 }
 // The AWS region the project's Bedrock models need, set before any model is called - here, and in the pi the chat starts,

package/dist/config.d.ts

@@ -379,6 +379,9 @@ export declare const DEFAULT_TEST_DIR = "tests";
 export declare function testDirOf(plainFile: string): string;
 /** The config a spec is built with: its project's, with its module's stack over it (`stackForModule`). */
 export declare function configForSpec(plainFile: string): ProjectConfig;
-/** One config file, read, or nothing of it when it is not there or does not parse. */
+/**
+ * One config file, read, or nothing of it when it is not there or does not parse. Parsed again only once the file has
+ * changed - its size or its modification time - and each caller given its own copy.
+ */
 export declare function readConfigFile(path: string): ProjectConfig;
 export {};

package/dist/config.js

@@ -81,14 +81,27 @@ export function stackConfigFile(stack) {
 function legacyStackConfigFile(stack) {
     return `config.${stack}.yaml`;
 }
+/**
+ * The names in a folder - read again only once the folder itself has changed: a name added, removed or renamed in it
+ * moves its modification time. Asked many times a look, for every module of every chain.
+ */
 function namesIn(root) {
     try {
-        return readdirSync(root);
+        const at = statSync(root).mtimeMs;
+        const kept = keptNames.get(root);
+        if (kept !== undefined && kept.at === at)
+            return [...kept.names];
+        const names = readdirSync(root);
+        keptNames.set(root, { at, names });
+        if (keptNames.size > 64)
+            keptNames.delete(keptNames.keys().next().value);
+        return [...names];
     }
     catch {
         return [];
     }
 }
+const keptNames = new Map();
 /** The stacks in the old naming, `config.<stack>.yaml`. */
 function legacyStacks(root) {
     return namesIn(root)
@@ -530,12 +543,34 @@ export function configForSpec(plainFile) {
     const root = projectDirOf(resolve(plainFile));
     return readProjectConfig(root, stackForModule(plainFile));
 }
-/** One config file, read, or nothing of it when it is not there or does not parse. */
+/**
+ * One config file, read, or nothing of it when it is not there or does not parse. Parsed again only once the file has
+ * changed - its size or its modification time - and each caller given its own copy.
+ */
 export function readConfigFile(path) {
-    let parsed;
+    let stamp;
     try {
-        if (!statSync(path).isFile())
+        const stat = statSync(path);
+        if (!stat.isFile())
             return {};
+        stamp = `${stat.size}:${stat.mtimeMs}:${stat.ino}`;
+    }
+    catch {
+        return {};
+    }
+    const kept = keptConfigs.get(path);
+    if (kept !== undefined && kept.stamp === stamp)
+        return structuredClone(kept.config);
+    const config = readConfigFileNow(path);
+    keptConfigs.set(path, { stamp, config });
+    if (keptConfigs.size > 64)
+        keptConfigs.delete(keptConfigs.keys().next().value);
+    return structuredClone(config);
+}
+const keptConfigs = new Map();
+function readConfigFileNow(path) {
+    let parsed;
+    try {
         parsed = loadYaml(readFileSync(path, "utf8"));
     }
     catch {

package/dist/environment.d.ts

@@ -22,8 +22,6 @@ export declare function themeFiles(): string[];
  * about a duplicate we created ourselves.
  */
 export declare function themesInstalledGlobally(): boolean;
-/** Where `turri` on the PATH points, if it is on the PATH at all. */
-export declare function turriOnPath(): string | undefined;
 /** The version of the pi turri runs on, as Node finds it - undefined when it is not installed. */
 export declare function piVersion(): string | undefined;
 /**

package/dist/environment.js

@@ -62,12 +62,6 @@ export function themesInstalledGlobally() {
     const names = themeFiles();
     return names.length > 0 && names.every((name) => existsSync(join(AGENT_DIR, "themes", name)));
 }
-/** Where `turri` on the PATH points, if it is on the PATH at all. */
-export function turriOnPath() {
-    const which = spawnSync(process.platform === "win32" ? "where" : "which", ["turri"], { encoding: "utf8" });
-    const found = which.status === 0 ? which.stdout.trim().split("\n")[0] : undefined;
-    return found === "" ? undefined : found;
-}
 /** The version of the pi turri runs on, as Node finds it - undefined when it is not installed. */
 export function piVersion() {
     try {

package/dist/extension.d.ts

@@ -107,13 +107,14 @@ export declare function parallelJobs(cwd: string): number;
 export declare function machineBlock(cwd: string, modules?: ReturnType<typeof stackOnMachine>): string;
 /**
  * What the project's modules need of this machine, kept between turns - working it out parses every spec, seconds on a
- * project of long requires chains, and a message is never kept waiting for it. Worked out once the chat is up, and again
- * when a turn has settled and a spec changed since: a turn is told what was known last, at most a turn behind.
+ * project of long requires chains. Worked out when the first turn asks - not as the session starts: a host's thread
+ * would be held up opening a chat no one may write in - and again, once known, when a turn has settled and a spec
+ * changed since: a turn is told what was known last, at most a turn behind.
  */
 export declare function machineNeeds(cwd: string, work?: (cwd: string) => ReturnType<typeof stackOnMachine>): {
     /** What is known - worked out now only when nothing is yet. */
     now(): ReturnType<typeof stackOnMachine>;
-    /** Worked out again, if a spec changed - once the chat has drawn what it is drawing. */
+    /** Worked out again, if it is known and a spec changed - once the chat has drawn what it is drawing. */
     refreshSoon(): void;
 };
 /**