@turri-dev/cli 0.1.25 → 0.1.26-next.f80f259

package/README.md

@@ -159,6 +159,7 @@ In a new project **turri** starts it itself, without asking how: it chooses the
 - **`/halt`** halts a pulse, **`/lineage`** shows every generation of a module, and the **`drift`** tool says what is left to regenerate;
 - **`/btw <question>`** asks turri something on the side - answered at once, even while a question waits for you (typed as the answer, under "Something else…"), and left out of the conversation;
 - **`/turri-config`** changes any setting of the project's `config.turri.yaml` - the models, review, conformance tests, how many pulses at once - and says when it takes effect: now, at your next message, or at the next pulse. No restart: `/turri-config review false`, or `/turri-config` alone to pick from the list;
+- **`/sentinel`** says whether the sentinel checks every pulse that finishes: `ask` (you are asked before it first opens), `on` or `off`;
 - **`/stack`** chooses the stack to build with, in a project whose backend and frontend each have their own testing scripts in `config.turri.<stack>.yaml` - `/stack backend`, `/stack none` - for the session (`--stack <name>` on the command line). The chat's model builds each part with its own stack by itself, pinned to that module's pulses.
 
 Other things to ask for:

package/dist/chat-records.d.ts

@@ -24,6 +24,10 @@ export interface RunRecord {
 /** How many runs' chats are kept: the most recent, the one `--continue` reopens, among them. */
 export declare const RUNS_KEPT = 5;
 export declare function chatsFile(project: string): string;
+/** A chat's saved conversation it no longer has - the sentinel's, before a pulse's fresh one - deleted, unless kept. */
+export declare function forgetSessionFile(file: string, options?: {
+    keep?: boolean;
+}): void;
 /** The runs recorded here, the most recent first. */
 export declare function recordedRuns(project: string): RunRecord[];
 /**

package/dist/chat-records.js

@@ -31,6 +31,11 @@ function write(project, file) {
         // A chat not recorded is not reopened; nothing else is lost.
     }
 }
+/** A chat's saved conversation it no longer has - the sentinel's, before a pulse's fresh one - deleted, unless kept. */
+export function forgetSessionFile(file, options = {}) {
+    if (options.keep !== true)
+        deleteSession(file);
+}
 function deleteSession(file) {
     try {
         rmSync(file, { force: true });

package/dist/chats.d.ts

@@ -2,6 +2,7 @@ import type { AgentSession, ExtensionAPI, ExtensionContext, ExtensionFactory, Ex
 import { type ChatScope } from "./chat-scope.ts";
 import { type RunRecord } from "./chat-records.ts";
 import { type ChatUi } from "./chat-ui.ts";
+import { type SentinelSetting } from "./config.ts";
 import type { AskUserIO } from "./ask.ts";
 import type { Job, JobRegistry } from "./regenerate/jobs.ts";
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
@@ -23,7 +24,10 @@ import { type ChatRole, type Conclusion, type Notice, type NoticeAnswer, type No
  *
  * With the project's sentinel on (sentinel.ts), every finished pulse goes to the sentinel - a chat of the session's own,
  * opened in the background with the first, and again after it is closed - and the chat the person looks at shows only
- * that it landed. What the sentinel finds wrong it puts to the person as a notice, in the chat they look at.
+ * that it landed. The sentinel checks each pulse in a conversation of its own: its chat keeps its id, and is given a new
+ * session for each pulse, one at a time. What the sentinel finds wrong it puts to the person as a notice, in the chat
+ * they look at. Under `sentinel: ask`, the person is asked first - a notice of turri's own, before it first opens in the
+ * session - the pulses that end meanwhile held until they answer.
  */
 /** The most chats a session has open at once. */
 export declare const MAX_CHATS = 9;
@@ -59,11 +63,16 @@ export interface TurriHost {
      * work: what it returns is what is sent. For a host that needs to change anything else.
      */
     systemPrompt?(prompt: string): string;
+    /**
+     * A chat's session replaced by a new one, under the same id: the sentinel's, a fresh conversation for each pulse it
+     * checks - told before the pulse is put to it. The host follows this session in place of the one it had.
+     */
+    onChatSession?(chat: string, session: AgentSession): void;
     /** The sentinel is done with a pulse - told to the chat it names, whose agent says so. */
     onConcluded?(conclusion: Conclusion & {
         chat: string;
     }): void;
-    /** What the sentinel puts to the person: the host draws it in the chat it names, and answers it with `answer`. */
+    /** 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. */
     onNoticeOver?(notice: Notice): void;
@@ -88,11 +97,10 @@ export interface ChatInstance {
     landed(job: Job, options?: {
         tell?: boolean;
     }): void;
-    /** The sentinel's: a pulse ended - its agent told, at once, or after what it does now; `replace`, what it does now stopped. */
+    /** The sentinel's: a pulse ended - its agent, in a conversation of its own for this pulse, told of it. */
     brief(job: Job, context: {
         asked?: string;
         focused?: string;
-        replace: boolean;
     }): Promise<void>;
     /** A notice put in the chat: drawn, and - in the terminal - put to the person once the chat is idle. */
     notice(notice: Notice): void;
@@ -207,8 +215,11 @@ export interface TurriCore {
     concluded(conclusion: Conclusion): string | undefined;
     /** The notices put to the person and not yet answered. */
     notices(): Notice[];
-    /** A notice answered: what it asked done in the chat it is in, or dismissed. */
-    answer(id: string, answer: NoticeAnswer): "done" | "dismissed" | "missing" | "over";
+    /**
+     * A notice answered: what it asked done in the chat it is in, dismissed, or - an ignorable one - ignored for good.
+     * `refused`: `ignore` on one that is not ignorable.
+     */
+    answer(id: string, answer: NoticeAnswer): "done" | "dismissed" | "ignored" | "refused" | "missing" | "over";
     /** For the extension: the jobs changed - every chat draws them again. */
     jobsChanged(): void;
     /** The chat whose work this is, else the one shown: its instance. */
@@ -229,8 +240,14 @@ export interface CoreOptions {
     persist?: boolean;
     /** The host's dialogs, a chat's own. */
     dialogs?: (chat: string) => AskUserIO | undefined;
-    /** Whether the project wants a sentinel - read as each pulse finishes. Unset: none. */
-    sentinel?: () => boolean;
+    /** 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;
+    /** 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. */
+    ignored?: (notice: Notice) => void;
 }
 /** A chat's session, as stopping what it does reaches it. */
 export type Stoppable = Pick<AgentSession, "isStreaming" | "isCompacting" | "isRetrying" | "isBashRunning" | "abort" | "abortBash">;

package/dist/chats.js

@@ -1,11 +1,11 @@
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { currentChat, inChat } from "./chat-scope.js";
-import { adoptRun, forgetChat, recordRun } from "./chat-records.js";
+import { adoptRun, forgetChat, forgetSessionFile, recordRun } from "./chat-records.js";
 import { createChatUi } from "./chat-ui.js";
 import { debugMode } from "./config.js";
 import { record } from "./regenerate/ledger.js";
-import { newNotice, noticeTask, SENTINEL, wentWrong } from "./notice.js";
+import { newNotice, noticeTask, SENTINEL, sentinelStartChoice, wentWrong } from "./notice.js";
 /**
  * The chats of a turri session.
  *
@@ -23,7 +23,10 @@ import { newNotice, noticeTask, SENTINEL, wentWrong } from "./notice.js";
  *
  * With the project's sentinel on (sentinel.ts), every finished pulse goes to the sentinel - a chat of the session's own,
  * opened in the background with the first, and again after it is closed - and the chat the person looks at shows only
- * that it landed. What the sentinel finds wrong it puts to the person as a notice, in the chat they look at.
+ * that it landed. The sentinel checks each pulse in a conversation of its own: its chat keeps its id, and is given a new
+ * session for each pulse, one at a time. What the sentinel finds wrong it puts to the person as a notice, in the chat
+ * they look at. Under `sentinel: ask`, the person is asked first - a notice of turri's own, before it first opens in the
+ * session - the pulses that end meanwhile held until they answer.
  */
 /** The most chats a session has open at once. */
 export const MAX_CHATS = 9;
@@ -88,8 +91,19 @@ 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 is on now, while its agent works: a newer one of the same module replaces a check of one that went well. */
-    let sentinelOnJob;
+    /** 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. */
+    let checking;
+    /** Pulses that finished while the sentinel was at work: each checked 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. */
+    let sentinelWork = Promise.resolve();
+    /**
+     * Under `sentinel: ask`, whether the person said to start the sentinel this session: asked - the notice `asking` open,
+     * the pulses that ended meanwhile `held` - started, or not this session.
+     */
+    let consent = "unasked";
+    let asking;
+    const held = [];
     const run = { run: randomUUID().slice(0, 8), pid: process.pid, started: new Date().toISOString(), chats: [] };
     const changed = () => {
         for (const listener of listeners) {
@@ -106,14 +120,19 @@ export function createChats(options) {
     const sentinelChat = () => chats.find((chat) => chat.role === SENTINEL);
     /** The person's chats: all but the sentinel. */
     const people = () => chats.filter((chat) => chat.role !== SENTINEL);
-    const wantsSentinel = () => {
+    const setting = () => {
         try {
-            return options.sentinel?.() === true;
+            return options.sentinel?.() ?? false;
         }
         catch {
             return false;
         }
     };
+    /** On, or asked for - and not declined this session. */
+    const wantsSentinel = () => {
+        const now = setting();
+        return now === true || (now === "ask" && consent !== "declined");
+    };
     /** The chat the person looks at, for what is put to them - never the sentinel: when it is shown, `fallback`, else their first. */
     const personFacing = (fallback) => {
         const shown = chats.find((chat) => chat.id === shownId);
@@ -160,12 +179,15 @@ export function createChats(options) {
             }
             else if (event.type === "agent_end") {
                 chat.working = false;
-                if (chat.role === SENTINEL)
-                    sentinelOnJob = undefined;
                 if (shownId !== chat.id)
                     chat.unread = true;
                 persist();
                 changed();
+                // 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));
+                }
             }
             else if (event.type === "session_info_changed") {
                 persist();
@@ -250,6 +272,14 @@ export function createChats(options) {
             }
             const recorded = run.chats.find((kept) => kept.id === id);
             chats.splice(chats.indexOf(chat), 1);
+            // 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;
+            }
+            // The question whether to start the sentinel was in it: put again in the chat the person looks at now.
+            if (asking?.chat === id)
+                askAgain();
             chat.unsubscribe?.();
             chat.ui?.close();
             inChat(chat.scope, () => record({ kind: "chat.closed" }, { project: cwd }));
@@ -343,26 +373,19 @@ export function createChats(options) {
         },
         sentinelOn: () => driver !== undefined && wantsSentinel(),
         jobFinished(job) {
+            // 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");
             if (core.sentinelOn()) {
+                if (consent === "asking" || (setting() === "ask" && consent === "unasked" && sentinelChat() === undefined && askToStart(job))) {
+                    held.push(job);
+                    changed();
+                    return;
+                }
                 sentinelFinished(job);
                 return;
             }
-            const asked = chats.find((chat) => chat.id === job.chat);
-            const chat = asked?.instance !== undefined ? asked : (core.shownChat() ?? chats[0]);
-            if (chat === undefined)
-                return;
-            if (chat.id !== shownId)
-                chat.unread = true;
-            try {
-                chat.instance?.announce(job);
-            }
-            catch {
-                // A chat let go as the pulse ended: the one shown is told instead.
-                const shown = core.shownChat();
-                if (shown !== undefined && shown !== chat)
-                    shown.instance?.announce(job);
-            }
-            changed();
+            toAsker(job);
         },
         jobsChanged() {
             for (const chat of chats) {
@@ -384,7 +407,9 @@ export function createChats(options) {
                 for (const older of open.filter((notice) => notice.state === "open" && notice.module === input.module))
                     over(older, "superseded");
             }
-            const notice = newNotice(input, target.id);
+            // 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);
             open.push(notice);
             if (target.id !== shownId)
                 target.unread = true;
@@ -437,6 +462,21 @@ export function createChats(options) {
                 return "missing";
             if (notice.state !== "open")
                 return "over";
+            // Left as the build has it, for good: nothing done in the chat, and the sentinel told not to raise it again.
+            if ("ignore" in answer) {
+                if (notice.ignorable !== true)
+                    return "refused";
+                try {
+                    options.ignored?.(notice);
+                }
+                catch (error) {
+                    core.notify(`The sentinel's guidance could not be written: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                }
+                over(notice, "ignored");
+                return "ignored";
+            }
+            if (notice.kind === "sentinel-start")
+                return answerStart(notice, answer);
             const task = noticeTask(notice, answer);
             over(notice, "dismiss" in answer ? "dismissed" : "steer" in answer ? "steered" : "accepted");
             if (task === undefined)
@@ -491,11 +531,94 @@ export function createChats(options) {
         if (chat !== undefined)
             inChat(chat.scope, () => record({ kind: "notice.over", notice: notice.id, state }, { project: cwd }));
     }
+    /** A pulse ended, told to the chat that asked for it - as without a sentinel - or the chat shown, when that one is closed. */
+    function toAsker(job) {
+        const asked = chats.find((chat) => chat.id === job.chat);
+        const chat = asked?.instance !== undefined ? asked : (core.shownChat() ?? chats[0]);
+        if (chat === undefined)
+            return;
+        if (chat.id !== shownId)
+            chat.unread = true;
+        try {
+            chat.instance?.announce(job);
+        }
+        catch {
+            // A chat let go as the pulse ended: the one shown is told instead.
+            const shown = core.shownChat();
+            if (shown !== undefined && shown !== chat)
+                shown.instance?.announce(job);
+        }
+        changed();
+    }
+    /**
+     * 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) {
+        let input;
+        try {
+            input = options.sentinelStart?.(job);
+        }
+        catch {
+            input = undefined;
+        }
+        if (input === undefined)
+            return false;
+        consent = "asking";
+        asking = core.notice({ ...input, kind: "sentinel-start" });
+        if (asking === undefined)
+            consent = "unasked";
+        return asking !== undefined;
+    }
+    /** The chat the question was put in is gone: it is put in the chat the person looks at - none left, the pulses go as without one. */
+    function askAgain() {
+        const question = asking;
+        over(question, "superseded");
+        asking = undefined;
+        consent = "unasked";
+        if (!askToStart(held[0]))
+            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. */
+    function answerStart(notice, answer) {
+        const choice = sentinelStartChoice(notice, answer);
+        try {
+            if (choice === "always" || choice === "never")
+                options.setSentinel?.(choice === "always");
+        }
+        catch (error) {
+            core.notify(`config.turri.yaml could not be written: ${error instanceof Error ? error.message : String(error)}`, "warning");
+        }
+        settleStart(choice === "start" || choice === "always" ? "given" : "declined", "dismiss" in answer ? "dismissed" : "steer" in answer ? "steered" : "accepted");
+        // Their own words are the chat's to act on: the sentinel is not started.
+        if ("steer" in answer) {
+            const task = noticeTask(notice, answer);
+            const chat = chats.find((candidate) => candidate.id === notice.chat) ?? personFacing();
+            if (task !== undefined)
+                chat?.instance?.act(task);
+        }
+        return "dismiss" in answer ? "dismissed" : "done";
+    }
+    /** Whether to start the sentinel is settled: its question closed, and the pulses held go to it - or, declined, to their chats. */
+    function settleStart(now, state) {
+        consent = now;
+        const question = asking;
+        asking = undefined;
+        if (question !== undefined && question.state === "open")
+            over(question, state);
+        for (const job of held.splice(0)) {
+            if (core.sentinelOn())
+                sentinelFinished(job);
+            else
+                toAsker(job);
+        }
+        changed();
+    }
     /**
      * A pulse ended, with the sentinel on: the chat the person looks at says so - its agent told of one that landed, to
      * tell the person it landed and what the sentinel does with it, and nothing more; of one that went wrong, not, the
-     * sentinel's notice being what it hears of it - and the sentinel is told, opened in the background when it is not open. A newer pulse of a module replaces a check of the
-     * module's last pulse that went well; one that went wrong is looked into to its end.
+     * sentinel's notice being what it hears of it - and the sentinel is given it, opened in the background when it is not
+     * open.
      */
     function sentinelFinished(job) {
         const asked = chats.find((chat) => chat.id === job.chat && chat.role !== SENTINEL);
@@ -511,7 +634,7 @@ export function createChats(options) {
             }
         }
         changed();
-        void (async () => {
+        toSentinel(async () => {
             let sentinel = sentinelChat();
             if (sentinel === undefined) {
                 try {
@@ -527,23 +650,137 @@ export function createChats(options) {
             }
             if (sentinel?.instance === undefined)
                 return;
-            const busy = sentinel.session?.isStreaming === true;
-            const replace = busy && sentinelOnJob !== undefined && !sentinelOnJob.wrong && sentinelOnJob.module !== undefined && sentinelOnJob.module === job.module;
-            sentinelOnJob = { module: job.module, wrong: wentWrong(job) };
-            if (sentinel.id !== shownId)
-                sentinel.unread = true;
+            await takePulse(sentinel, job);
+        });
+    }
+    /** The sentinel's work, after what it was given before. */
+    function toSentinel(work) {
+        sentinelWork = sentinelWork.then(work).catch((error) => {
+            core.notify(`The sentinel: ${error instanceof Error ? error.message : String(error)}`, "warning");
+        });
+    }
+    /** 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.
+     */
+    function takePulse(sentinel, job) {
+        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));
+        if (older !== -1)
+            waiting.splice(older, 1, job);
+        else
+            waiting.push(job);
+    }
+    /** The sentinel free again: the next pulse that waits, checked. */
+    function nextPulse(sentinel) {
+        if (!chats.includes(sentinel) || sentinelBusy(sentinel))
+            return;
+        const job = waiting.shift();
+        if (job !== undefined)
+            return check(sentinel, job);
+    }
+    /**
+     * 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) };
+        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;
+        if (session !== undefined && (session.messages.length > 0 || session.isStreaming))
+            await freshConversation(sentinel);
+        if (sentinel.id !== shownId)
+            sentinel.unread = true;
+        const asked = chats.find((chat) => chat.id === job.chat && chat.role !== SENTINEL && chat.instance !== undefined);
+        const where = personFacing(asked);
+        try {
+            await sentinel.instance.brief(job, {
+                ...(asked !== undefined ? { asked: titleFor(asked) } : {}),
+                ...(where !== undefined ? { focused: titleFor(where) } : {}),
+            });
+        }
+        catch (error) {
+            core.notify(`The sentinel could not be told of ${job.id}: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            checking = undefined;
+        }
+        changed();
+    }
+    /**
+     * The sentinel's chat given a new session, under the same id: what it does now stopped, and what it said let go - its
+     * saved conversation deleted outside debug mode. The model and thinking it had carry over: what the person picked in
+     * it stands. Shown in the terminal, the screen is drawn from the new one. A new session that cannot be made leaves it
+     * the one it had.
+     */
+    async function freshConversation(chat) {
+        const old = { session: chat.session, services: chat.services, instance: chat.instance };
+        chat.unsubscribe?.();
+        chat.unsubscribe = undefined;
+        try {
+            await old.session.abort();
+        }
+        catch {
+            /* stopped already */
+        }
+        chat.working = false;
+        const model = old.session.model;
+        const thinking = old.session.thinkingLevel;
+        // Made as a chat is opened, one at a time: its extension built while it is the one attaching.
+        const made = opening.then(async () => {
+            attaching = chat;
             try {
-                await sentinel.instance.brief(job, {
-                    ...(asked !== undefined ? { asked: titleFor(asked) } : {}),
-                    ...(where !== undefined ? { focused: titleFor(where) } : {}),
-                    replace,
-                });
+                await driver.create(chat, undefined);
             }
-            catch (error) {
-                core.notify(`The sentinel could not be told of ${job.id}: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            finally {
+                attaching = undefined;
             }
-            changed();
-        })();
+        });
+        opening = made.catch(() => undefined);
+        try {
+            await made;
+        }
+        catch (error) {
+            Object.assign(chat, old);
+            follow(chat);
+            core.notify(`The sentinel goes on in the conversation it had - a new one could not be started: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            return;
+        }
+        const fresh = chat.session;
+        try {
+            if (model !== undefined && fresh.model !== model)
+                await fresh.setModel(model);
+            if (thinking !== undefined)
+                fresh.setThinkingLevel(thinking);
+        }
+        catch {
+            /* the model its session started on, then */
+        }
+        follow(chat);
+        if (shownId === chat.id)
+            await driver?.show?.(chat, undefined);
+        try {
+            old.session.dispose();
+        }
+        catch {
+            /* let go already */
+        }
+        if (old.session.sessionFile !== undefined && old.session.sessionFile !== fresh.sessionFile)
+            forgetSessionFile(old.session.sessionFile, { keep: debugMode(cwd) });
+        try {
+            host.onChatSession?.(chat.id, fresh);
+        }
+        catch {
+            /* a host that throws still has the chat's new session in session(id) */
+        }
+        persist();
+        changed();
     }
     return core;
 }

package/dist/config-command.js

@@ -139,6 +139,36 @@ export function registerTurriConfig(pi, options) {
         }
         return top.find((setting) => chosen.startsWith(`${setting.key}:`));
     };
+    // /sentinel: its one setting by its own name - asked before it first opens in a session, on without asking, or off.
+    const sentinelChoices = [
+        ["ask", "ask", "you are asked, with what it does, before it first opens in a session"],
+        ["on", "true", "it opens with the first pulse that finishes, without asking"],
+        ["off", "false", "no sentinel: each pulse is told to the chat that asked for it"],
+    ];
+    pi.registerCommand("sentinel", {
+        description: "Whether the sentinel checks every finished pulse: ask first, on, or off",
+        getArgumentCompletions: (prefix) => {
+            const items = sentinelChoices.filter(([word]) => word.startsWith(prefix.trim().toLowerCase()));
+            return items.length === 0 ? null : items.map(([word, , about]) => ({ value: word, label: word, description: about }));
+        },
+        handler: async (args, ctx) => {
+            const setting = settingOf("sentinel");
+            const typed = args.trim().toLowerCase();
+            let word = typed;
+            if (word === "") {
+                if (!ctx.hasUI)
+                    return;
+                const now = currentValue(readConfigText(cwd), setting.key);
+                const lines = sentinelChoices.map(([choice, , about]) => `${choice} - ${about}`);
+                const chosen = await ctx.ui.select(`/sentinel - now: ${now === undefined ? `unset - ${setting.unset}` : shownValue(now)}`, lines);
+                if (chosen === undefined)
+                    return;
+                word = chosen.slice(0, chosen.indexOf(" "));
+            }
+            const value = sentinelChoices.find(([choice]) => choice === word)?.[1] ?? word;
+            await apply(setting, value, ctx);
+        },
+    });
     pi.registerCommand("turri-config", {
         description: `Change a setting of the project's ${CONFIG_FILE}`,
         getArgumentCompletions: (prefix) => {

package/dist/config-edit.js

@@ -66,7 +66,7 @@ export function settings(rules = []) {
         { key: "mutation-testing", about: "whether the coding agent and the reviewer can put a bug in the code for one test run (can_it_fail)", kind: "boolean", unset: "true", effect: "next-pulse" },
         { key: "allow-to-stop-jobs", about: "whether turri stops a running pulse the ***plain has moved on from", kind: "boolean", unset: "true", effect: "now" },
         { key: "release-after-pulse", about: "whether every pulse that lands code releases it", kind: "boolean", unset: "false", effect: "next-landing" },
-        { key: "sentinel", about: "whether a chat of its own checks every finished pulse, tests the release, and tells you what is wrong", kind: "boolean", unset: "true", effect: "next-landing" },
+        { key: "sentinel", about: "whether a chat of its own checks every finished pulse, tests the release, and tells you what is wrong - ask: you are asked before it first opens", kind: "choice", options: ["ask", "true", "false"], unset: "ask", effect: "next-landing" },
         { key: "unittests-script", about: "the unit testing script, by path from the project root", kind: "path", unset: "the one run_unittests*.sh found", effect: "next-test-run" },
         { key: "conformance-tests-script", about: "the conformance testing script, by path from the project root", kind: "path", unset: "the one run_conformance_tests*.sh found", effect: "next-test-run" },
         { key: "prepare-environment-script", about: "run on the build before every conformance testing script run, by path from the project root - optional", kind: "path", unset: "the one prepare_environment*.sh found, else none", effect: "next-test-run" },
@@ -119,7 +119,7 @@ export function parseValue(setting, typed, known) {
         case "choice": {
             const word = text.toLowerCase();
             if (setting.options?.includes(word))
-                return { value: setting.key === "conformance-tests" && word === "false" ? false : word };
+                return { value: word === "false" ? false : word === "true" ? true : word };
             return { error: `${setting.key} is one of ${setting.options?.join(", ")}.` };
         }
         case "number": {

package/dist/config.d.ts

@@ -19,7 +19,7 @@
  * mutation-testing: false                                   # give the coding agent and the reviewer can_it_fail (default: true)
  * allow-to-stop-jobs: false                                 # stop a running job the spec moved on from (default: true)
  * release-after-pulse: true                                 # release what each pulse lands, as its last stage, before the next pulse (default: false)
- * sentinel: false                                           # a chat of its own every finished pulse goes to, which tests the release and tells you what is wrong (default: true)
+ * sentinel: true                                            # a chat of its own every finished pulse goes to, which tests the release and tells you what is wrong: true, false, or ask - the person asked before it first opens in a session (default: ask)
  * rules-off: [integrations]                                 # ***plain rules to leave out of the prompts, by name (default: none)
  * unittests-script: test_scripts/run_unittests.sh           # the testing scripts - see test-scripts.ts
  * conformance-tests-script: test_scripts/run_conformance_tests.sh
@@ -174,6 +174,8 @@ export declare function projectModels(config: Pick<ProjectConfig, "harnessModel"
 export declare function roleModel(config: Pick<ProjectConfig, "harnessModel" | "judgeModel" | "models">, role: AgentRole): ModelChoice | undefined;
 /** How long each turn of a role's agents may take, in milliseconds: its own, `default`'s, `turn-limit:`'s - or undefined, the harness's default. */
 export declare function roleTurnLimitMs(config: Pick<ProjectConfig, "models" | "turnLimit">, role: AgentRole | undefined): number | undefined;
+/** `sentinel:` - on, off, or `ask`: on once the person says so, asked before it first opens in a session. */
+export type SentinelSetting = boolean | "ask";
 export interface ProjectConfig {
     /** The .plain file the module command builds when it is given none. */
     module?: string;
@@ -228,9 +230,10 @@ export interface ProjectConfig {
     releaseAfterPulse?: boolean;
     /**
      * Whether the session has a sentinel: a chat of its own that every finished pulse goes to - checked, a release tested,
-     * and what is wrong put to the person - instead of the chat that asked for it (docs/sentinel.md). Unset: true.
+     * and what is wrong put to the person - instead of the chat that asked for it (docs/sentinel.md). `ask`: the person is
+     * asked, before it first opens in a session, whether to start it. Unset: ask.
      */
-    sentinel?: boolean;
+    sentinel?: SentinelSetting;
     /** Path from the root to the unit testing script. */
     unittestsScript?: string;
     /** Path from the root to the conformance testing script. */

package/dist/config.js

@@ -25,7 +25,7 @@ import { projectDirOf } from "./regenerate/paths.js";
  * mutation-testing: false                                   # give the coding agent and the reviewer can_it_fail (default: true)
  * allow-to-stop-jobs: false                                 # stop a running job the spec moved on from (default: true)
  * release-after-pulse: true                                 # release what each pulse lands, as its last stage, before the next pulse (default: false)
- * sentinel: false                                           # a chat of its own every finished pulse goes to, which tests the release and tells you what is wrong (default: true)
+ * sentinel: true                                            # a chat of its own every finished pulse goes to, which tests the release and tells you what is wrong: true, false, or ask - the person asked before it first opens in a session (default: ask)
  * rules-off: [integrations]                                 # ***plain rules to leave out of the prompts, by name (default: none)
  * unittests-script: test_scripts/run_unittests.sh           # the testing scripts - see test-scripts.ts
  * conformance-tests-script: test_scripts/run_conformance_tests.sh
@@ -561,7 +561,7 @@ function readConfigFile(path) {
         mutationTesting: typeof raw[CONFIG_KEYS.mutationTesting] === "boolean" ? raw[CONFIG_KEYS.mutationTesting] : undefined,
         allowToStopJobs: typeof raw[CONFIG_KEYS.allowToStopJobs] === "boolean" ? raw[CONFIG_KEYS.allowToStopJobs] : undefined,
         releaseAfterPulse: typeof raw[CONFIG_KEYS.releaseAfterPulse] === "boolean" ? raw[CONFIG_KEYS.releaseAfterPulse] : undefined,
-        sentinel: typeof raw[CONFIG_KEYS.sentinel] === "boolean" ? raw[CONFIG_KEYS.sentinel] : undefined,
+        sentinel: typeof raw[CONFIG_KEYS.sentinel] === "boolean" || raw[CONFIG_KEYS.sentinel] === "ask" ? raw[CONFIG_KEYS.sentinel] : undefined,
         unittestsScript: text(raw[CONFIG_KEYS.unittestsScript]),
         conformanceTestsScript: text(raw[CONFIG_KEYS.conformanceTestsScript]),
         prepareEnvironmentScript: text(raw[CONFIG_KEYS.prepareEnvironmentScript]),