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

package/dist/extension.js

@@ -55,6 +55,7 @@ import { inheritProviders, inheritThinkingLevel } from "./pi.js";
 import { beginCapture, captureConsole, describeCaptured, dropNoise } from "./quiet.js";
 import { loadRules, renderRulesBlock } from "./rules.js";
 import { registerTurriConfig } from "./config-command.js";
+import { writeSetting } from "./config-edit.js";
 import { describeStdlib } from "./stdlib.js";
 import { DECLINED, peekKeyListener, runAsk } from "./ask.js";
 import { QuestionDialog } from "./question-dialog.js";
@@ -64,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, sentinelOn, sentinelPrompt, 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";
@@ -321,8 +322,12 @@ export function createTurriCore(host = {}, options = {}) {
         host,
         jobs,
         extension: (pi, link) => turriExtension(pi, core, link),
-        // A finished pulse goes to the sentinel when the project wants one - read as each pulse finishes.
-        sentinel: () => sentinelOn(cwd),
+        // A finished pulse goes to the sentinel when the project wants one - read as each pulse finishes - the person asked
+        // first under `sentinel: ask`, and what they choose for the project written.
+        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 } : {}),
     });
@@ -437,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,
@@ -451,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/host.d.ts

@@ -6,7 +6,7 @@
  */
 export { createTurri, type Turri, type TurriOptions } from "./host-session.ts";
 export { MAX_CHATS, type ChatInfo, type ChatStatus, type TurriHost } from "./chats.ts";
-export { SENTINEL, type Conclusion, type Notice, type NoticeAction, type NoticeAnswer, type NoticeSeverity, type NoticeState } from "./notice.ts";
+export { SENTINEL, SENTINEL_START, type Conclusion, type Notice, type NoticeAction, type NoticeAnswer, type NoticeSeverity, type NoticeState } from "./notice.ts";
 export type { AskUserIO } from "./ask.ts";
 /** pi itself, as turri is built against it: a host's own extensions and UI are made with this one, not another copy. */
 export * as pi from "@earendil-works/pi-coding-agent";

package/dist/host.js

@@ -8,7 +8,7 @@
 export { createTurri } from "./host-session.js";
 export { MAX_CHATS } from "./chats.js";
 // The sentinel's notices: what it puts to the person, and how they answer.
-export { SENTINEL } from "./notice.js";
+export { SENTINEL, SENTINEL_START } from "./notice.js";
 /** pi itself, as turri is built against it: a host's own extensions and UI are made with this one, not another copy. */
 export * as pi from "@earendil-works/pi-coding-agent";
 // The project and its settings.

package/dist/init-config.d.ts

@@ -113,7 +113,7 @@ export declare const DEFAULTS: {
     readonly mutationTesting: true;
     readonly allowToStopJobs: true;
     readonly releaseAfterPulse: true;
-    readonly sentinel: true;
+    readonly sentinel: "ask";
     readonly testingScriptsRunOn: "in-place";
     readonly turnLimit: 120;
     readonly compactAt: 100000;

package/dist/init-config.js

@@ -220,7 +220,7 @@ export const DEFAULTS = {
     mutationTesting: true,
     allowToStopJobs: true,
     releaseAfterPulse: true,
-    sentinel: true,
+    sentinel: "ask",
     testingScriptsRunOn: "in-place",
     turnLimit: 120,
     compactAt: 100000,
@@ -266,7 +266,8 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         `release-after-pulse: ${DEFAULTS.releaseAfterPulse}`,
         "",
         "# Whether a chat of its own, the sentinel, checks every pulse that finishes - and, with release-after-pulse, tests what",
-        "# was released - and tells you in the chat you are in when something needs you.",
+        "# was released - and tells you in the chat you are in when something needs you. ask: you are asked, with what it does,",
+        "# before it first opens in a session; true: it opens without asking; false: none.",
         `sentinel: ${DEFAULTS.sentinel}`,
         "",
         "# What the testing scripts run on: in-place - the code itself; copy - a fresh copy of it.",

package/dist/notice.d.ts

@@ -13,6 +13,11 @@ export interface NoticeAction {
     task: string;
 }
 export interface NoticeInput {
+    /**
+     * `sentinel-start`: not something wrong but a question turri puts before the sentinel first opens in a session - its
+     * actions start it, or not, and are turri's to carry out, not the chat's agent's (SENTINEL_START). None: the sentinel's.
+     */
+    kind?: "sentinel-start";
     severity: NoticeSeverity;
     /** What is wrong, in a line. */
     summary: string;
@@ -24,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. */
@@ -33,17 +44,37 @@ export interface Notice extends NoticeInput {
     state: NoticeState;
     at: string;
 }
-/** How the person answered a notice: one of its actions (by index or label), their own words, or not at all. */
+/** The answers to the question put before the sentinel first opens: the actions of a `sentinel-start` notice, in order. */
+export declare const SENTINEL_START: {
+    readonly start: "Start the sentinel";
+    readonly always: "Start it, and don't ask again";
+    readonly notNow: "Not this session";
+    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, 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

@@ -5,12 +5,26 @@ import { randomUUID } from "node:crypto";
  */
 /** Its name in the strip, the host's chat list, and the ledger. */
 export const SENTINEL = "sentinel";
+/** The answers to the question put before the sentinel first opens: the actions of a `sentinel-start` notice, in order. */
+export const SENTINEL_START = {
+    start: "Start the sentinel",
+    always: "Start it, and don't ask again",
+    notNow: "Not this session",
+    never: "Turn it off for this project",
+};
 export function newNotice(input, chat) {
     return { ...input, id: randomUUID().slice(0, 8), chat, state: "open", at: new Date().toISOString() };
 }
+/** The choice an answer to a `sentinel-start` notice makes: dismissed, or answered in the person's own words, it is not now. */
+export function sentinelStartChoice(notice, answer) {
+    if (!("action" in answer))
+        return "notNow";
+    const label = typeof answer.action === "number" ? notice.actions[answer.action]?.label : answer.action;
+    return Object.keys(SENTINEL_START).find((choice) => SENTINEL_START[choice] === label) ?? "notNow";
+}
 /** 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"}:`,
@@ -24,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.d.ts

@@ -3,6 +3,11 @@ import type { ChatLink, TurriCore } from "./chats.ts";
 import { type Conclusion, type Notice } from "./sentinel.ts";
 /** The sentinel's tools and model, built into its chat. */
 export declare function registerSentinel(pi: ExtensionAPI, session: TurriCore, cwd: string, hostTools: ToolDefinition[], allowed: Set<string>): void;
+/**
+ * The terminal's question whether to start the sentinel: the sentence, and how to switch to it - it opens last in the
+ * strip, after the `open` chats there are. A host has its own way to it, and is given the sentence alone.
+ */
+export declare function startTitle(notice: Notice, open: number): string;
 /**
  * A chat's notices: each drawn as a card, and - with no host to answer it - put to the person as a dialog once the chat
  * is idle, one at a time: an action accepted, their own words, or dismissed. A notice that is over closes its dialog.

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. */
@@ -54,6 +55,13 @@ export function registerSentinel(pi, session, cwd, hostTools, allowed) {
             pi.setThinkingLevel(choice.thinking);
     });
 }
+/**
+ * The terminal's question whether to start the sentinel: the sentence, and how to switch to it - it opens last in the
+ * strip, after the `open` chats there are. A host has its own way to it, and is given the sentence alone.
+ */
+export function startTitle(notice, open) {
+    return `${notice.summary}\nUse "/chat ${open + 1}" to open the sentinel.`;
+}
 /**
  * A chat's notices: each drawn as a card, and - with no host to answer it - put to the person as a dialog once the chat
  * is idle, one at a time: an action accepted, their own words, or dismissed. A notice that is over closes its dialog.
@@ -92,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;
@@ -114,8 +130,15 @@ export function noticeDialogs(pi, session, link, context) {
         const controller = new AbortController();
         asking.set(notice.id, controller);
         try {
-            const options = [...notice.actions.map((action, index) => `${index + 1}. ${action.label}`), STEER, DISMISS];
-            const picked = await ctx.ui.select(`sentinel: ${notice.summary}`, options, { signal: controller.signal });
+            // 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}`),
+                ...(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;
             if (picked === STEER) {
@@ -128,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.d.ts

@@ -1,4 +1,5 @@
 import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type SentinelSetting } from "./config.ts";
 import { type Job } from "./regenerate/jobs.ts";
 import type { DeployedProcess } from "./regenerate/release.ts";
 import { type Conclusion, type Notice, type NoticeInput } from "./notice.ts";
@@ -10,8 +11,13 @@ export * from "./notice.ts";
  * file tools only read, its shell runs with the project read only, and it has none of the tools that change ***plain or
  * start work. The chat the person talks to is never interrupted for a pulse that went well.
  */
-/** Whether the project wants a sentinel: `sentinel:` in config.turri.yaml, true unset. */
-export declare function sentinelOn(cwd: string): boolean;
+/** Whether the project wants a sentinel: `sentinel:` in config.turri.yaml - true, false, or ask, as it is unset. */
+export declare function sentinelSetting(cwd: string): SentinelSetting;
+/**
+ * What the person is asked before the sentinel first opens in a session, under `sentinel: ask`, in one sentence: the pulse
+ * that would open it and what it does - so a tab that starts working on its own is not a surprise - and whether to start it.
+ */
+export declare function sentinelStartNotice(job: Job, cwd: string): NoticeInput;
 /** A pulse that stopped on ***plain that contradicts itself: put to the person by turri itself, the way out the chat's to work out. */
 export declare function specConflictNotice(job: Job, task: string): NoticeInput;
 export declare function guidanceFile(cwd: string): string;

package/dist/sentinel.js

@@ -10,7 +10,7 @@ import { formatDuration, pulseName } from "./regenerate/jobs.js";
 import { readLedger } from "./regenerate/ledger.js";
 import { describePulseView, pulseView } from "./regenerate/ledger-view.js";
 import { MODULES_DIR, ensureInScratch } from "./regenerate/paths.js";
-import { SENTINEL, wentWrong } from "./notice.js";
+import { SENTINEL, SENTINEL_START, wentWrong } from "./notice.js";
 export * from "./notice.js";
 /**
  * The sentinel: a chat of the session's own that every finished pulse goes to (docs/sentinel.md). It checks how each
@@ -19,15 +19,42 @@ export * from "./notice.js";
  * file tools only read, its shell runs with the project read only, and it has none of the tools that change ***plain or
  * start work. The chat the person talks to is never interrupted for a pulse that went well.
  */
-/** Whether the project wants a sentinel: `sentinel:` in config.turri.yaml, true unset. */
-export function sentinelOn(cwd) {
+/** Whether the project wants a sentinel: `sentinel:` in config.turri.yaml - true, false, or ask, as it is unset. */
+export function sentinelSetting(cwd) {
     try {
-        return readProjectConfig(cwd).sentinel !== false;
+        return readProjectConfig(cwd).sentinel ?? "ask";
     }
     catch {
-        return true;
+        return "ask";
     }
 }
+/**
+ * What the person is asked before the sentinel first opens in a session, under `sentinel: ask`, in one sentence: the pulse
+ * that would open it and what it does - so a tab that starts working on its own is not a surprise - and whether to start it.
+ */
+export function sentinelStartNotice(job, cwd) {
+    let released = false;
+    try {
+        released = readProjectConfig(cwd).releaseAfterPulse === true;
+    }
+    catch {
+        /* a config that cannot be read releases nothing */
+    }
+    return {
+        kind: "sentinel-start",
+        severity: "info",
+        summary: `${pulseName(job)} finished - start the sentinel, a background tab that reviews each finished pulse${released ? " and tries to use what was released" : ""}?`,
+        evidence: [],
+        actions: [
+            { label: SENTINEL_START.start, task: "The sentinel is started for this session: this pulse and each after it go to it." },
+            { label: SENTINEL_START.always, task: "The sentinel is started, and sentinel: true written to config.turri.yaml: it opens without asking from now on." },
+            { label: SENTINEL_START.notNow, task: "No sentinel this session: each pulse is told to the chat that asked for it. turri asks again next time." },
+            { label: SENTINEL_START.never, task: "sentinel: false written to config.turri.yaml: no sentinel, and no asking." },
+        ],
+        job: job.id,
+        ...(job.pulse !== undefined ? { pulse: job.pulse } : {}),
+    };
+}
 /** A pulse that stopped on ***plain that contradicts itself: put to the person by turri itself, the way out the chat's to work out. */
 export function specConflictNotice(job, task) {
     return {
@@ -110,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."]
             : [
@@ -118,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",
@@ -129,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 !== ""
             ? [
                 "",
@@ -238,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({
@@ -245,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

@@ -21,7 +21,7 @@ The session's, shared by every chat:
 - **what `activate` started** - it runs until turri ends or `/halt activated <name>`, whatever chats are opened or closed;
 - **the ledger** - one run, each event with the id of the chat its work was asked for in (`chat`), and `chat.opened` and `chat.closed` as they happen.
 
-A pulse's end goes to the [sentinel](sentinel.md) - a chat of turri's own, opened in the background with the first pulse that finishes - which checks it, tests what was released, and puts what needs you as a notice in the chat you are in. That chat shows the pulse's end; its agent is told of a pulse that landed, to tell you so and what the sentinel is doing with it - and when the sentinel is done with any pulse, what it found - and nothing more - and not of one that went wrong: the sentinel's notice is what it hears of that. With `sentinel: false`, a pulse's end is told to the chat that asked for it instead, shown or not - its agent reacts to it there; the chat's mark in the strip says it has something new. When that chat has been closed, the chat shown is told. Closing a chat stops its turn, never its pulses.
+A pulse's end goes to the [sentinel](sentinel.md) - a chat of turri's own, opened in the background with the first pulse that finishes, once you said to start it under `sentinel: ask` - which checks it, tests what was released, and puts what needs you as a notice in the chat you are in. That chat shows the pulse's end; its agent is told of a pulse that landed, to tell you so and what the sentinel is doing with it - and when the sentinel is done with any pulse, what it found - and nothing more - and not of one that went wrong: the sentinel's notice is what it hears of that. With `sentinel: false`, a pulse's end is told to the chat that asked for it instead, shown or not - its agent reacts to it there; the chat's mark in the strip says it has something new. When that chat has been closed, the chat shown is told. Closing a chat stops its turn, never its pulses.
 
 ## In the terminal
 
@@ -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/config.md

@@ -90,7 +90,7 @@ models:                              # each agent role's model, thinking and tur
 | `rules-off` | a list of rule names - `integrations`, `concise-specs`, the files of `genome/rules/` without `.md` - left out of the conversation's prompt and every \*\*\*plain-writing agent's: a rule this project's own skills or AGENTS.md replace, such as one that says to probe a live API before any \*\*\*plain is written. `turri init-config` writes it with `integration-embedded`, `integration-embedded-testing` and `integration-standalone` - take them out when the project writes an integration against a REST API. The project's alone | none |
 | `allow-to-stop-jobs` | `true` or `false`: whether turri stops a running job \*\*\*plain has moved on from - a functional spec it regenerates changed, or a file one links was edited - rolls it back and regenerates \*\*\*plain as it now is. `false`: the job runs to its end and lands, and what changed since is regenerated on top of it by the next job - see [regenerating the code](regenerating.md). Your own `halt` stops a job either way | `true` |
 | `release-after-pulse` | `true` or `false`: whether every pulse that lands code releases it, in the chat, as its last stage - before the module's next pulse starts, whatever the chat is doing: an agent on the coding model releases it, following the project's release guidance as the chat finds it (what was passed to `release` this conversation, AGENTS.md, the project's skills) for how, or to `dist/<module>` without any - see [deploy](deploy.md#after-every-pulse). One release a pulse that lands; a release that fails is said in the pulse's report, and what it landed stays. `turri init-config` writes `true` | `false` |
-| `sentinel` | `true` or `false`: whether a chat of turri's own, the sentinel, gets every pulse that finishes - checks it, tests what was released under `release-after-pulse`, and puts what needs you as a notice in the chat you are in - instead of the chat that asked for it. See [the sentinel](sentinel.md). `turri init-config` writes `true` | `true` |
+| `sentinel` | `ask`, `true` or `false`: whether a chat of turri's own, the sentinel, gets every pulse that finishes - checks it, tests what was released under `release-after-pulse`, and puts what needs you as a notice in the chat you are in - instead of the chat that asked for it. `ask`: you are asked, with what it does, before it first opens in a session - see [starting it](sentinel.md#starting-it); `true`: it opens without asking. `/sentinel` sets it from the chat. `turri init-config` writes `ask` | `ask` |
 | `unittests-script` | the unit testing script, by path from the project root - it runs the code's static checks too, exiting 80 when only they fail (see [the static checks](regenerating.md#the-static-checks)) | looked for - see below |
 | `conformance-tests-script` | the conformance testing script, by path from the project root | looked for - see below |
 | `prepare-environment-script` | optional: run as `<script> <build>` before every run of the conformance testing script, which runs only once it passes - see [the testing scripts](regenerating.md#the-testing-scripts). turri never writes one | the one `prepare_environment*.sh` at the root or in `test_scripts/`, else none |

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,10 @@ 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).
 - **Its tools.** `sentinel: { tools }` are [pi](https://pi.dev) tool definitions registered in the sentinel's chat alone and told to it in its prompt - the host's browser, say, for it to test a release with. The rest of the host's `extensions` are built into its chat too, but their tools are refused it: only its own read, and these.