@turri-dev/cli 0.1.26-next.2fc445f → 0.1.26-next.f80f259

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

@@ -24,9 +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. 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.
+ * 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;
@@ -62,6 +63,11 @@ 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;
@@ -91,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;
@@ -210,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. */
@@ -238,6 +246,8 @@ export interface CoreOptions {
     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,7 +1,7 @@
 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";
@@ -23,9 +23,10 @@ import { newNotice, noticeTask, SENTINEL, sentinelStartChoice, wentWrong } from
  *
  * 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. 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.
+ * 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;
@@ -90,8 +91,12 @@ 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.
@@ -174,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();
@@ -264,6 +272,11 @@ 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();
@@ -394,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;
@@ -447,6 +462,19 @@ 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);
@@ -589,8 +617,8 @@ export function createChats(options) {
     /**
      * 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);
@@ -606,7 +634,7 @@ export function createChats(options) {
             }
         }
         changed();
-        void (async () => {
+        toSentinel(async () => {
             let sentinel = sentinelChat();
             if (sentinel === undefined) {
                 try {
@@ -622,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/extension.js

@@ -65,7 +65,7 @@ import { supersededByTurri } from "./chat-skills.js";
 import { conversationIdentity } from "./identity.js";
 import { setSurface, surfaceOf } from "./surface.js";
 import { createChats, scopedToChat } from "./chats.js";
-import { landedNote, pulseEndsBlock, SENTINEL, SENTINEL_TOOLS, sentinelBrief, sentinelPrompt, sentinelSetting, sentinelStartNotice, specConflictNotice } from "./sentinel.js";
+import { ignoredGuidance, keepGuidance, landedNote, pulseEndsBlock, SENTINEL, SENTINEL_TOOLS, sentinelBrief, sentinelPrompt, sentinelSetting, sentinelStartNotice, specConflictNotice } from "./sentinel.js";
 import { noticeDialogs, registerSentinel } from "./sentinel-chat.js";
 import { currentChat } from "./chat-scope.js";
 import { registerChats } from "./chat-commands.js";
@@ -327,6 +327,7 @@ export function createTurriCore(host = {}, options = {}) {
         sentinel: () => sentinelSetting(cwd),
         sentinelStart: (job) => sentinelStartNotice(job, cwd),
         setSentinel: (on) => void writeSetting(cwd, "sentinel", on),
+        ignored: (notice) => keepGuidance(cwd, ignoredGuidance(notice)),
         ...(options.persist !== undefined ? { persist: options.persist } : {}),
         ...(options.dialogs !== undefined ? { dialogs: options.dialogs } : {}),
     });
@@ -441,11 +442,10 @@ function turriExtension(api, session, link) {
             details: { jobId: job.id, status: job.status },
         }, { triggerTurn: true, deliverAs: "followUp" });
     };
-    // The sentinel's: what a pulse that ended is, told to its agent - after what it does now, or in its place.
+    // The sentinel's: what a pulse that ended is, told to its agent in a conversation of its own for the pulse. The hidden
+    // message is the conversation's first entry - a host splits the sentinel's work by pulse on it - so the pulse's end is
+    // not drawn above it here: the person's chat shows it.
     const brief = async (job, context) => {
-        if (context.replace)
-            await link.session()?.abort();
-        announceJob(pi, job);
         const config = readProjectConfig(cwd);
         const content = sentinelBrief(job, {
             project: cwd,
@@ -455,8 +455,7 @@ function turriExtension(api, session, link) {
             releaseAfterPulse: config.releaseAfterPulse === true,
             reaction: JOB_FINISHED_REACTION,
         });
-        const busy = link.session()?.isStreaming === true;
-        void pi.sendMessage({ customType: "turri_sentinel_pulse", content, display: false, details: { jobId: job.id, status: job.status } }, { triggerTurn: true, ...(busy ? { deliverAs: "followUp" } : {}) });
+        void pi.sendMessage({ customType: "turri_sentinel_pulse", content, display: false, details: { jobId: job.id, status: job.status } }, { triggerTurn: true });
     };
     // A pulse ended, with the sentinel on: said in the chat. One that landed is told to its agent too, to tell the person
     // it landed and what the sentinel does with it - and nothing more: the pulse is the sentinel's. ***plain that

package/dist/host-session.d.ts

@@ -68,9 +68,11 @@ export interface Turri {
     notices(): Notice[];
     /**
      * A notice answered: one of its actions (by index or label) - the chat it is in started on it - the person's own words
-     * about it, or dismissed. `over` when it was answered or superseded already, `missing` for one never put.
+     * about it, dismissed, or - `ignorable: true` - ignored for good: left as the build has it, the sentinel told not to
+     * raise it again. `refused` for `ignore` on one that is not ignorable, `over` when it was answered or superseded
+     * already, `missing` for one never put.
      */
-    answer(id: string, answer: NoticeAnswer): Promise<"done" | "dismissed" | "missing" | "over">;
+    answer(id: string, answer: NoticeAnswer): Promise<"done" | "dismissed" | "ignored" | "refused" | "missing" | "over">;
     /** Told when a chat is opened, closed, renamed, or starts or stops working. */
     onChats(listener: (chats: ChatInfo[]) => void): () => void;
     /** Every chat let go, and what activate started stopped. */

package/dist/notice.d.ts

@@ -29,8 +29,14 @@ export interface NoticeInput {
     job?: string;
     /** Its number among its module's pulses. */
     pulse?: number;
+    /**
+     * The person may leave it as the build has it, for good (`{ ignore: true }`): a gap in the ***plain the build settled
+     * with an assumption - never something broken, a pulse that went wrong, a release that did not come up, nor the
+     * question whether to start the sentinel.
+     */
+    ignorable?: boolean;
 }
-export type NoticeState = "open" | "accepted" | "steered" | "dismissed" | "superseded";
+export type NoticeState = "open" | "accepted" | "steered" | "dismissed" | "ignored" | "superseded";
 export interface Notice extends NoticeInput {
     id: string;
     /** The chat it is put in: the one the person looks at, never the sentinel's. */
@@ -46,19 +52,29 @@ export declare const SENTINEL_START: {
     readonly never: "Turn it off for this project";
 };
 export type SentinelStartChoice = keyof typeof SENTINEL_START;
-/** How the person answered a notice: one of its actions (by index or label), their own words, or not at all. */
+/**
+ * How the person answered a notice: one of its actions (by index or label), their own words, not at all this once
+ * (`dismiss`) - or, on an ignorable one, not at all and not again (`ignore`): left as the build has it.
+ */
 export type NoticeAnswer = {
     action: number | string;
 } | {
     steer: string;
 } | {
     dismiss: true;
+} | {
+    ignore: true;
 };
 export declare function newNotice(input: NoticeInput, chat: string): Notice;
 /** The choice an answer to a `sentinel-start` notice makes: dismissed, or answered in the person's own words, it is not now. */
 export declare function sentinelStartChoice(notice: Notice, answer: NoticeAnswer): SentinelStartChoice;
 /** What the focused chat's agent is asked to do once the person answered a notice - undefined when they dismissed it. */
 export declare function noticeTask(notice: Notice, answer: NoticeAnswer): string | undefined;
+/**
+ * What the sentinel keeps of a notice the person ignored, in its guidance: what was left as it is - its module, the gap,
+ * what the build does - and why, so a fresh conversation does not raise it again.
+ */
+export declare function ignoredGuidance(notice: Notice): string;
 /** A notice in words: its summary, its evidence and what can be done - for the agent, the log and a chat without a card. */
 export declare function describeNotice(notice: NoticeInput): string;
 /** Whether a pulse went wrong: failed, stopped, or ran to its end with what it built not passing. */

package/dist/notice.js

@@ -24,7 +24,7 @@ export function sentinelStartChoice(notice, answer) {
 }
 /** What the focused chat's agent is asked to do once the person answered a notice - undefined when they dismissed it. */
 export function noticeTask(notice, answer) {
-    if ("dismiss" in answer)
+    if ("dismiss" in answer || "ignore" in answer)
         return undefined;
     const head = [
         `The sentinel put this to the person, about ${notice.module !== undefined ? `${notice.module}${notice.pulse !== undefined ? ` pulse ${notice.pulse}` : ""}` : "the work"}:`,
@@ -38,6 +38,15 @@ export function noticeTask(notice, answer) {
         return undefined;
     return [...head, `The person chose: ${action.label}. Do it now:`, action.task.trim()].join("\n");
 }
+/**
+ * What the sentinel keeps of a notice the person ignored, in its guidance: what was left as it is - its module, the gap,
+ * what the build does - and why, so a fresh conversation does not raise it again.
+ */
+export function ignoredGuidance(notice) {
+    const about = notice.module !== undefined ? ` in ${notice.module}` : "";
+    const shows = notice.evidence.length > 0 ? ` (${notice.evidence.join("; ")})` : "";
+    return `The person chose to leave this${about} as the build has it - do not raise it again unless the build no longer does what they accepted: ${notice.summary}${shows}`;
+}
 /** A notice in words: its summary, its evidence and what can be done - for the agent, the log and a chat without a card. */
 export function describeNotice(notice) {
     return [

package/dist/regenerate/ledger.d.ts

@@ -60,6 +60,10 @@ export type LedgerEvent = {
     kind: "notice.over";
     notice: string;
     state: string;
+} | {
+    kind: "sentinel.checking";
+    module?: string;
+    replaced?: string;
 } | {
     kind: "sentinel.concluded";
     verdict: string;

package/dist/sentinel-chat.js

@@ -12,6 +12,7 @@ const NOTICE_ENTRY = "turri_notice";
 const NOTICE_OVER_ENTRY = "turri_notice_over";
 /** The sentinel done with a pulse, in the chat the person is in. */
 const CONCLUDED_ENTRY = "turri_sentinel_concluded";
+const IGNORE = "Ignore - leave it as the build has it";
 const STEER = "Say what to do instead…";
 const DISMISS = "Dismiss";
 /** The sentinel's tools and model, built into its chat. */
@@ -99,7 +100,15 @@ export function noticeDialogs(pi, session, link, context) {
         const data = entry.data;
         if (data === undefined)
             return undefined;
-        const said = data.state === "superseded" ? "superseded by a newer notice" : data.state === "dismissed" ? "dismissed" : data.state === "steered" ? "answered in your words" : "accepted";
+        const said = data.state === "superseded"
+            ? "superseded by a newer notice"
+            : data.state === "dismissed"
+                ? "dismissed"
+                : data.state === "ignored"
+                    ? "ignored - left as the build has it, not raised again"
+                    : data.state === "steered"
+                        ? "answered in your words"
+                        : "accepted";
         const box = new Box(1, 0);
         box.addChild(new Text(theme.fg("muted", `  ${said}: ${data.summary}`), 0, 0));
         return box;
@@ -123,7 +132,12 @@ export function noticeDialogs(pi, session, link, context) {
         try {
             // Whether to start the sentinel is turri's question, its answers its own: no words of the person's to act on.
             const starting = notice.kind === "sentinel-start";
-            const options = [...notice.actions.map((action, index) => `${index + 1}. ${action.label}`), ...(starting ? [] : [STEER]), DISMISS];
+            const options = [
+                ...notice.actions.map((action, index) => `${index + 1}. ${action.label}`),
+                ...(notice.ignorable === true ? [IGNORE] : []),
+                ...(starting ? [] : [STEER]),
+                DISMISS,
+            ];
             const picked = await ctx.ui.select(starting ? startTitle(notice, session.chats().length) : `sentinel: ${notice.summary}`, options, { signal: controller.signal });
             if (controller.signal.aborted || notice.state !== "open")
                 return;
@@ -137,6 +151,10 @@ export function noticeDialogs(pi, session, link, context) {
                     session.answer(notice.id, { steer: words });
                 return;
             }
+            if (picked === IGNORE) {
+                session.answer(notice.id, { ignore: true });
+                return;
+            }
             const index = options.indexOf(picked ?? DISMISS);
             session.answer(notice.id, index >= 0 && index < notice.actions.length ? { action: index } : { dismiss: true });
         }

package/dist/sentinel.js

@@ -137,7 +137,8 @@ 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, as a message turri writes - what the pulse was, how it ended,",
+        "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,",
         ...(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."]
             : [
@@ -145,7 +146,7 @@ export function sentinelPrompt(cwd, options = {}) {
                 "they talk to you in another chat, and hear what you find only through notify_person.",
             ]),
         "",
-        "For each pulse:",
+        "For the pulse:",
         "1. Check how it went, from what turri tells you - and, when that is not enough, its log, the ledger (ledger, pulses),",
         "   diagnose, and the code and the ***plain, which you read.",
         "2. When it was released (the message says so - release-after-pulse is on), test what was released: it is running",
@@ -156,17 +157,21 @@ export function sentinelPrompt(cwd, options = {}) {
         "   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.",
+        "   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.",
         "4. When all is well, notify no one.",
-        "5. Last, call conclude once for the pulse - holds or wrong, and in a line or two what you checked and what you found:",
+        "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. A newer message about the same module can arrive while you check an older pulse",
-        "that went well: leave the older one and check the newer.",
+        "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.",
+        "run - keep it with keep_guidance, in their words, so it holds from now on: this conversation ends with its pulse,",
+        "and the next pulse's starts afresh, with only what you kept. What the person chose to leave as the build has it is",
+        "in your guidance too: do not raise it again, unless the build no longer does what they accepted.",
         ...(surface !== ""
             ? [
                 "",
@@ -265,6 +270,11 @@ 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" })),
+            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 " +
+                    "passwords over 72 bytes; the build refuses them with 422). Never for something broken, a pulse that went wrong, or a release that did not come up.",
+            })),
         }),
         async execute(_id, params) {
             const notice = notify({
@@ -272,6 +282,7 @@ export function notifyTool(notify) {
                 summary: params.summary,
                 evidence: params.evidence,
                 actions: params.actions,
+                ...(params.ignorable === true ? { ignorable: true } : {}),
                 ...(params.module !== undefined ? { module: params.module } : {}),
                 ...(params.pulse !== undefined ? { job: params.pulse } : {}),
             });

package/docs/chats.md

@@ -45,7 +45,7 @@ On macOS, `alt` is Option (⌥), and reaches turri only when the terminal sends
 - **The side panel** (`ctrl+h`) is the session's, not a chat's: docked beside the chat or over it, it stays as another chat is shown, and opening it from any chat finds it as it was left.
 - **A long command** - `/regenerate`, planning a module from scratch - does its work in the background once it is under way: the chat, and switching to another, stay free while the planner plans.
 - **`ctrl+c`** reaches the chat shown and nothing else: another chat's turn and skill go on, and so do the pulses - `/halt` stops one. A skill stopped keeps its run, for the model to continue with `resume`. At a question - the chat's `ask_user`, a skill's interview - `ctrl+c` declines it, and the asker is told so and goes on - each question it is pressed at, however many in a row. A skill is stopped by `ctrl+c` with no question open. A second press straight after one that stopped something does nothing, so pressing twice to be sure does not leave turri; once the chat is doing nothing, the next one does - with what every other chat is doing. A host has the same as `interrupt(id)`, and `decline(id)` for a question ([hosting](hosting.md)).
-- **The sentinel** is a chat in the strip like the others, `sentinel`, and never shown by itself: it closes like any chat, and the next pulse that finishes opens it again. With it on, you open up to eight chats - the ninth slot is its. See [the sentinel](sentinel.md).
+- **The sentinel** is a chat in the strip like the others, `sentinel`, and never shown by itself: it closes like any chat, and the next pulse that finishes opens it again. Each pulse it checks in a fresh conversation, replacing the one in its tab. With it on, you open up to eight chats - the ninth slot is its. See [the sentinel](sentinel.md).
 - **The last chat** of yours is not closed: `/quit` leaves turri. Leaving turri leaves the terminal as it was: the conversation is not written out to it, nor a line on how to resume - the command run is all that stays. `turri --continue` opens the chats again.
 - **`/fork`** and **`/reload`** work on the chat shown, as [pi](https://pi.dev)'s do: the chat's history forked, or turri's extension rebuilt in it.
 - **A chat shown mid-turn** draws its reply as far as it is written, and follows it from there.

package/docs/hosting.md

@@ -84,8 +84,9 @@ const turri = await createTurri({
   extensions: [browser, terminal],     // the host's own extensions, built into every chat after turri's
   restore: true,                       // reopen the last session's chats here, as `turri --continue` does
   onNotice: (notice) => {},            // the sentinel puts something to the person: draw it in notice.chat
-  onNoticeOver: (notice) => {},        // ...answered, dismissed or superseded: take its card down
+  onNoticeOver: (notice) => {},        // ...answered, dismissed, ignored or superseded: take its card down
   onConcluded: (conclusion) => {},     // the sentinel is done with a pulse: holds or wrong, told to conclusion.chat
+  onChatSession: (chat, session) => {}, // a chat's session replaced, same id: the sentinel's, fresh for each pulse - follow this one
   sentinel: {
     tools: [browserTool],               // the sentinel's own tools, beside turri's: what it tests a release with
     surface: "...",                     // where the person watches it use them, in the host's words
@@ -100,7 +101,7 @@ await turri.interrupt(chat.id);        // ctrl+c: "stopped" what it was doing, e
 await turri.decline(chat.id);          // ctrl+c at a question: "declined", the turn going on - "none", "missing"
 turri.chats();                         // [{ id, title, status: "idle" | "working" | "question" | "unread", shown, role? }]
 turri.notices();                       // the notices open now
-await turri.answer(notice.id, { action: 0 }); // or { steer: "…" }, { dismiss: true }: "done", "dismissed", "over", "missing"
+await turri.answer(notice.id, { action: 0 }); // or { steer: "…" }, { dismiss: true }, { ignore: true }: "done", "dismissed", "ignored", "refused", "over", "missing"
 turri.onChats((chats) => {});          // a chat opened, closed, renamed, working or done
 await turri.closeChat(chat.id);        // its turn stopped, its conversation deleted - its pulses run on
 turri.jobs;                            // the session's job registry: every pulse any chat started
@@ -122,7 +123,9 @@ await turri.dispose();                 // every chat let go, what activate start
 
 The [sentinel](sentinel.md) is one of the host's chats: turri opens it with the first pulse that finishes, through the host's own `create` like any chat - `onChats` hears of it, `role: "sentinel"` - and never moves `focus` to it. It closes like any chat, and the next pulse that finishes opens it again; with it on, `openChat` opens up to eight.
 
-- **Notices.** What it finds wrong comes as `onNotice(notice)`: `{ id, chat, severity: "error" | "warning" | "info", summary, evidence: string[], actions: [{ label, task }], module?, pulse?, job?, state: "open" }`. Draw it in the chat `chat` names - the one `focus` last named, or, while that is the sentinel, the chat that asked for the pulse. It is drawn there as a card in the transcript too. A host given `onNotice` answers it itself - the terminal's dialog is not opened - with `answer(id, …)`: `{ action: index | label }` starts that chat's agent on the action's task, `{ steer: text }` on the person's words, `{ dismiss: true }` on nothing. `onNoticeOver(notice)` comes as it is answered - and when a newer notice about its module supersedes it (`state: "superseded"`) - for the host to take the card down. `notices()` lists the open ones.
+- **A conversation a pulse.** The sentinel checks each pulse from scratch, in a conversation of its own - one pulse at a time, the others waiting their turn. The chat keeps its id; its session is replaced. As it starts on a pulse, the session it had is stopped and let go (`abort`, `dispose`), a new one is made in its place, and `onChatSession(chat, session)` comes with it - before the pulse is put to it - then `onChats`; `session(id)` returns the new one from then on. A host that follows the sentinel's chat subscribes to that session in place of the old - an `onChats` listener that follows only the ids it has not seen would hear nothing more of it. The first pulse goes to the session the chat was opened with: there is no `onChatSession` for it. Each conversation's first message is the hidden brief of its pulse - `customType: "turri_sentinel_pulse"`, `details.jobId` - so a host that splits the sentinel's work by pulse on it still can; the conversations before are not in the new session, and what the host showed of them is its own to keep.
+
+- **Notices.** What it finds wrong comes as `onNotice(notice)`: `{ id, chat, severity: "error" | "warning" | "info", summary, evidence: string[], actions: [{ label, task }], module?, pulse?, job?, ignorable?, state: "open" }`. Draw it in the chat `chat` names - the one `focus` last named, or, while that is the sentinel, the chat that asked for the pulse. It is drawn there as a card in the transcript too. A host given `onNotice` answers it itself - the terminal's dialog is not opened - with `answer(id, …)`: `{ action: index | label }` starts that chat's agent on the action's task, `{ steer: text }` on the person's words, `{ dismiss: true }` on nothing, this once. A notice with `ignorable: true` - a gap in the \*\*\*plain the build settled with an assumption, which the person may leave as it is - takes `{ ignore: true }` too: offer it as its own button beside the actions. Nothing is done in the chat, the notice ends `state: "ignored"` (`"ignored"`), and turri writes it to the sentinel's guidance, so it is not raised again in this session or the next; on a notice without `ignorable`, `{ ignore: true }` is `"refused"` and the notice stays open. `onNoticeOver(notice)` comes as it is answered - and when a newer notice about its module supersedes it (`state: "superseded"`) - for the host to take the card down. `notices()` lists the open ones.
 - **Starting it.** Under `sentinel: ask` - as it is unset - the person is asked before it first opens in the session: a notice with `kind: "sentinel-start"`, `severity: "info"`, in the chat `chat` names, its `summary` the question in one sentence, no `evidence`, and its actions the answers - `Start the sentinel`, `Start it, and don't ask again`, `Not this session`, `Turn it off for this project`. Draw it as a question rather than as something wrong. `answer(id, { action })` answers it, by index or label - `"done"` - and `{ dismiss: true }` is not this session; turri writes `sentinel:` itself for the two that choose for the project. Until it is answered, the pulses that finish are held: neither the sentinel nor the chat hears of them. A host that offers the setting too writes it as `/turri-config` does - `ask`, `true` or `false` (see `configSettings`).
 - **Conclusions.** As the sentinel is done with each pulse - all well or not - `onConcluded({ job, verdict: "holds" | "wrong", summary, module, pulse, chat })` comes, and the chat `chat` names - the one `focus` last named, as for a notice - shows it and its agent says so in a line.
 - **Its model.** The `sentinel` role in `models:`, else the chat's model - `models.chat`, else `harness-model` - with its thinking, set as its chat opens: not pi's default model, which may not be one the project's provider has. What the person then picks in its chat stands. See [its model](sentinel.md#its-model).

package/docs/sentinel.md

@@ -20,17 +20,18 @@ Nothing goes to the sentinel, or to your chat, until you answer: the pulses that
 ## What you see
 
 - **In the chat you are in**, a pulse that finishes shows as it always has - `✓ app · regenerate pulse 3 finished after 4m 10s`, and for one that went wrong, where to see why. A pulse that landed is told to the chat's agent, which tells you in a line or two what landed and what the sentinel is doing with it - and again, in a line, when the sentinel is done with it - checking it, testing what was released - and does nothing else about it: it does not test, release or open it, nor do what the project's guidance says to do once a pulse finishes. The pulse is the sentinel's. A pulse that went wrong is not told to it: the sentinel looks into it, and you hear of it as a notice.
-- **The sentinel** opens with the first pulse that finishes - once you said to start it, under `sentinel: ask` - in the background: it never takes the screen, and you stay in your chat. It is a tab in the strip like any other chat - `sentinel` - marked while it works and when it has something new. Switch to it to read what it checked.
+- **The sentinel** opens with the first pulse that finishes - once you said to start it, under `sentinel: ask` - in the background: it never takes the screen, and you stay in your chat. It is a tab in the strip like any other chat - `sentinel` - marked while it works and when it has something new. Switch to it to read what it checked: it shows the pulse it is on, or the last one it checked - each pulse has a conversation of its own (below).
 - **A notice**, when something needs you: a card in the chat you are in - what is wrong, what shows it, and what can be done, numbered - and, in the terminal, once that chat is not mid-turn, a dialog on it:
   - `enter` on an action accepts it: the chat's agent is started on it - a change to the \*\*\*plain, a pulse regenerated again, a credential to provide, a setting to change;
+  - **Ignore - leave it as the build has it**, on a notice the sentinel marked ignorable: nothing is done, and it is not raised again - in this session or the next (below);
   - **Say what to do instead…** - your own words, and the agent does that;
-  - **Dismiss**, or `esc`: nothing is done.
+  - **Dismiss**, or `esc`: nothing is done, this once - the next pulse may raise it again.
 
   Nothing is done without your answer. A notice goes to the chat you are in; while you are in the sentinel's, to the chat that asked for the pulse. There is one open notice a module: a newer one about the same module supersedes the older one, whose call to action would be stale, and the card says so.
 
 ## What it does
 
-For each pulse that finishes, turri writes the sentinel what it was and how it ended - its stages, rounds and failures as the [ledger](using.md#the-ledger) has them, its \*\*\*plain diff, its log, the chat that asked for it, the chat you are in, and what was released and where it runs. Then it:
+Each pulse it checks from scratch, in a conversation of its own: its prompt, your guidance (`.turri/sentinel.md`, below) and what turri writes it of that pulse - nothing of the pulses before it. Its chat stays the same tab; the conversation in it is replaced as it starts on the next pulse, and the one before is let go - deleted, outside [debug mode](config.md). For each pulse that finishes, turri writes the sentinel what it was and how it ended - its stages, rounds and failures as the [ledger](using.md#the-ledger) has them, its \*\*\*plain diff, its log, the chat that asked for it, the chat you are in, and what was released and where it runs. Then it:
 
 1. **checks the pulse** - from what it is told, and when that is not enough, from the pulse's log, the ledger (`ledger`, `pulses`), `diagnose`, the code and the \*\*\*plain;
 2. **tests the release**, with `release-after-pulse` on: what was released is running where it is told, and it tries it - in the terminal with its shell (`curl`, the program itself, the logs), in a host also with what the host gives it, a browser say. How far it tests is its own judgement, from what the pulse changed and what the \*\*\*plain says it now does. With `release-after-pulse` off nothing is running, and it checks the pulse alone;
@@ -38,7 +39,11 @@ For each pulse that finishes, turri writes the sentinel what it was and how it e
 4. **notifies no one** when all is well;
 5. **concludes**, last, whether all is well or not: what it checked and what it found, in a line or two. The chat you are in shows it - `✓ sentinel · app · pulse 3 · checked, it holds` - and its agent tells you so in a line, and does nothing more; when something was wrong, that its notice says what.
 
-A pulse that went well is checked until a newer pulse of its module finishes: that one is checked instead. A pulse that went wrong is looked into to its end. Two functional specs that contradict each other stop a pulse in a way only you can settle: turri puts that notice itself, with an action that starts your chat on working it out with you.
+It checks one pulse at a time. A pulse that finishes while it works waits its turn, and is checked once it is done - from scratch, as every pulse is. A pulse that went well is checked until a newer pulse of its module finishes: its check is stopped, and the newer one is checked instead, at once - and a newer pulse of a module takes the place of one of it that went well and waits. A pulse that went wrong is looked into to its end.
+
+A notice may be **ignorable**: the sentinel marks one so when you may reasonably leave it as it is - chiefly a gap in the \*\*\*plain the build settled with an assumption: *the \*\*\*plain does not say what happens to passwords over 72 bytes; the build refuses them with 422*. Never something broken, a pulse that went wrong, a release that did not come up, nor the question whether to start the sentinel. Ignore one and it is left as the build has it, for good: nothing is done in your chat, and a line is written to the sentinel's guidance (`.turri/sentinel.md`, as `keep_guidance` writes) saying what was left as it is - its module, the gap, what the build does - and that you chose to. Every conversation after has it, and does not raise it again - unless the build no longer does what you accepted. To have it raised again, take the line out of `.turri/sentinel.md`.
+
+Two functional specs that contradict each other stop a pulse in a way only you can settle: turri puts that notice itself, with an action that starts your chat on working it out with you.
 
 ## What it may do
 
@@ -46,22 +51,22 @@ Nothing that changes the project. Its file tools - `read`, `ls`, `grep`, `find`
 
 ## Talking to it
 
-Switch to its chat and say how to check your software - *test the sign-up flow at a phone's width*, *ignore the styling*, *the API runs on port 8080*. What should hold from now on it keeps with `keep_guidance`, in `.turri/sentinel.md`, and it is in its prompt from then on - after it is closed and opened again too.
+Switch to its chat and say how to check your software - *test the sign-up flow at a phone's width*, *ignore the styling*, *the API runs on port 8080*. What should hold from now on it keeps with `keep_guidance`, in `.turri/sentinel.md`, and it is in its prompt from then on - for every pulse after, and after it is closed and opened again too. Nothing else you say carries over: the conversation you talk to it in is the pulse's, and the next pulse starts a fresh one. A pulse that finishes while it answers you waits until it has.
 
 ## Closing it
 
-It closes like any chat (`/chat close`, `alt+w`, a host's `closeChat`), and that does not turn it off: the next pulse that finishes opens it again, with a fresh conversation - and your guidance. `turri --continue` reopens it with the other chats, as it was. `sentinel: false` - in `config.turri.yaml`, or with `/sentinel off` or `/turri-config` - turns it off: from the next pulse that finishes, a pulse is told to the chat that asked for it, whose agent reacts to it, as without one.
+It closes like any chat (`/chat close`, `alt+w`, a host's `closeChat`), and that does not turn it off: what it was checking is stopped, the pulses that waited for it are let go, and the next pulse that finishes opens it again, with a fresh conversation - and your guidance. `turri --continue` reopens it with the other chats, with the conversation of the last pulse it was on; the next pulse starts a fresh one. `sentinel: false` - in `config.turri.yaml`, or with `/sentinel off` or `/turri-config` - turns it off: from the next pulse that finishes, a pulse is told to the chat that asked for it, whose agent reacts to it, as without one.
 
 It has a slot of its own: with it on, you open up to eight chats, and the ninth is the sentinel's, open or not.
 
 ## Its model
 
-The `sentinel` role in `models:` - else the chat's model, `models.chat` else `harness-model`, with its thinking - see [models](config.md#models). A `sentinel` entry that gives only `thinking` runs on the chat's model, thinking as it says. It is set as the sentinel's chat opens, in the terminal and in a host alike - never the model its session started on, which in a host is [pi](https://pi.dev)'s default and may not be one the project's provider has. What the person then picks in its chat stands. Judging behaviour against \*\*\*plain, and driving a browser, want a capable model; point it at a cheaper one if it costs too much for every pulse.
+The `sentinel` role in `models:` - else the chat's model, `models.chat` else `harness-model`, with its thinking - see [models](config.md#models). A `sentinel` entry that gives only `thinking` runs on the chat's model, thinking as it says. It is set as the sentinel's chat opens, in the terminal and in a host alike - never the model its session started on, which in a host is [pi](https://pi.dev)'s default and may not be one the project's provider has. What the person then picks in its chat stands, through each pulse's fresh conversation, until it is closed. Judging behaviour against \*\*\*plain, and driving a browser, want a capable model; point it at a cheaper one if it costs too much for every pulse.
 
 ## In a host
 
-A host sees the sentinel as one of its chats - `role: "sentinel"` in `chats()` and `onChats` - and never has focus moved to it. Under `sentinel: ask`, the question before it first opens comes as a notice like the others, with `kind: "sentinel-start"`, its actions the four answers: `answer(id, { action })` answers it - by index or label - and `{ dismiss: true }` is not this session. Each notice comes as `onNotice(notice)` - `{ id, chat, module, pulse, job, severity, summary, evidence, actions, state }`, `chat` the one to draw it in - and `onNoticeOver(notice)` when it is answered or superseded; `notices()` lists those open. `answer(id, { action } | { steer } | { dismiss: true })` answers one, as the terminal's dialog does. `onConcluded({ job, verdict: "holds" | "wrong", summary, module, pulse, chat })` comes as it is done with a pulse, all well or not - told to the chat `chat` too. The sentinel's own tools - a browser - are given with `createTurri({ sentinel: { tools } })`, and it is told it has them. `sentinel: { surface }` says, in the host's words, where the person watches it use them: then it tries a release with them, where the person can watch, and keeps its shell for what they cannot show - logs, exit codes, files. Without it, the person does not watch the sentinel, and the host's tools are only to test with as well. See [running turri in a host](hosting.md#the-sentinel).
+A host sees the sentinel as one of its chats - `role: "sentinel"` in `chats()` and `onChats` - and never has focus moved to it. Each pulse's fresh conversation is a new pi session in the same chat, under the same id: `onChatSession(chat, session)` comes before the pulse is put to it, and `session(id)` returns the new one. Under `sentinel: ask`, the question before it first opens comes as a notice like the others, with `kind: "sentinel-start"`, its actions the four answers: `answer(id, { action })` answers it - by index or label - and `{ dismiss: true }` is not this session. Each notice comes as `onNotice(notice)` - `{ id, chat, module, pulse, job, severity, summary, evidence, actions, state }`, `chat` the one to draw it in - and `onNoticeOver(notice)` when it is answered or superseded; `notices()` lists those open. `answer(id, { action } | { steer } | { dismiss: true } | { ignore: true })` answers one, as the terminal's dialog does - `{ ignore: true }` only on a notice with `ignorable: true`, `"refused"` on any other; it ends `state: "ignored"`. `onConcluded({ job, verdict: "holds" | "wrong", summary, module, pulse, chat })` comes as it is done with a pulse, all well or not - told to the chat `chat` too. The sentinel's own tools - a browser - are given with `createTurri({ sentinel: { tools } })`, and it is told it has them. `sentinel: { surface }` says, in the host's words, where the person watches it use them: then it tries a release with them, where the person can watch, and keeps its shell for what they cannot show - logs, exit codes, files. Without it, the person does not watch the sentinel, and the host's tools are only to test with as well. See [running turri in a host](hosting.md#the-sentinel).
 
 ## In the ledger
 
-`chat.opened` carries `role: "sentinel"` for its chat; `notice.put` and `notice.over` record each notice - the question before it opens among them - - its severity and module, and how it ended: `accepted`, `steered`, `dismissed`, `superseded` - and `sentinel.concluded` each pulse it is done with, `holds` or `wrong`.
+`chat.opened` carries `role: "sentinel"` for its chat; `sentinel.checking` each pulse it starts a conversation for - `replaced`, the pulse of the same module whose check it stopped; `notice.put` and `notice.over` record each notice - the question before it opens among them - - its severity and module, and how it ended: `accepted`, `steered`, `dismissed`, `ignored`, `superseded` - and `sentinel.concluded` each pulse it is done with, `holds` or `wrong`.

package/docs/using.md

@@ -187,7 +187,7 @@ It is in `.turri/ledger/` in the project, a JSON line an event, one file a run -
 | the healers | `healer.started`, `healer.ended` with what it found, `healer.failed` and why - the debugger, the diagnosis of a failed pulse |
 | the history | `history.committed`, `history.failed`, `history.reset`, `history.rolledBack` |
 | the environment | `environment.error` |
-| chats and notices | `chat.opened` (`role: "sentinel"` for the [sentinel](sentinel.md)'s), `chat.closed`, `notice.put` (its severity and module), `notice.over` (accepted, steered, dismissed or superseded), `sentinel.concluded` (`holds` or `wrong`, a pulse the sentinel is done with) |
+| chats and notices | `chat.opened` (`role: "sentinel"` for the [sentinel](sentinel.md)'s), `chat.closed`, `notice.put` (its severity and module), `notice.over` (accepted, steered, dismissed, ignored or superseded), `sentinel.checking` (a pulse the sentinel starts a conversation for - `replaced`, the one whose check it stopped), `sentinel.concluded` (`holds` or `wrong`, a pulse the sentinel is done with) |
 
 Never in it: prompts, replies, thinking, tool arguments and results, file contents - the one body it keeps is each pulse's \*\*\*plain diff, so what an earlier session regenerated can be read back. What an event does carry - a stage, an error's first line - is masked as the logs are.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.26-next.2fc445f",
+  "version": "0.1.26-next.f80f259",
   "license": "MIT",
   "type": "module",
   "repository": {