@turri-dev/cli 0.1.19 → 0.1.20

package/dist/extension.js

@@ -64,6 +64,8 @@ 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 { noticeDialogs, registerSentinel } from "./sentinel-chat.js";
 import { currentChat } from "./chat-scope.js";
 import { registerChats } from "./chat-commands.js";
 import { turriIdentity } from "./environment.js";
@@ -319,6 +321,8 @@ 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),
         ...(options.persist !== undefined ? { persist: options.persist } : {}),
         ...(options.dialogs !== undefined ? { dialogs: options.dialogs } : {}),
     });
@@ -383,6 +387,13 @@ export function sessionLoop(session) {
 function turriExtension(api, session, link) {
     const pi = scopedToChat(api, link.scope);
     const { cwd, host, jobs } = session;
+    // The session's sentinel: its own prompt and tools - the project to read, notices, its guidance - and nothing that
+    // changes the project or starts work.
+    const isSentinel = link.role === SENTINEL;
+    const hostSentinelTools = isSentinel ? (host.sentinel?.tools ?? []) : [];
+    const sentinelAllowed = new Set([...SENTINEL_TOOLS, ...hostSentinelTools.map((tool) => tool.name)]);
+    if (isSentinel)
+        registerSentinel(pi, session, cwd, hostSentinelTools, sentinelAllowed);
     const dialogs = link.dialogs ?? host.dialogs;
     // turri's own skills, and the project's - .turri/skills, .agents/skills (skills.ts).
     const discoveredSkills = discoverSkills(PACKAGE_ROOT, cwd);
@@ -426,8 +437,45 @@ 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.
+    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,
+            ...(context.asked !== undefined ? { asked: context.asked } : {}),
+            ...(context.focused !== undefined ? { focused: context.focused } : {}),
+            released: runningDeployed(job.module),
+            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" } : {}) });
+    };
+    // 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
+    // contradicts itself is put to the person at once, by turri itself, as the chat would have been started on it.
+    const landed = (job, options = {}) => {
+        announceJob(pi, job);
+        if (job.specConflict !== undefined)
+            session.notice(specConflictNotice(job, specConflictTask(job.specConflict)));
+        if (options.tell !== true)
+            return;
+        void pi.sendMessage({ customType: "turri_job_landed", content: landedNote(job, runningDeployed(job.module)), display: false, details: { jobId: job.id, status: job.status } }, { triggerTurn: true, deliverAs: "followUp" });
+    };
+    const notices = noticeDialogs(pi, session, link, contextNow);
     link.live({
         announce,
+        landed,
+        brief,
+        notice: notices.put,
+        noticeOver: notices.over,
+        concluded: notices.concluded,
+        act: (task) => {
+            void pi.sendMessage({ customType: "turri_notice_answer", content: task, display: false }, { triggerTurn: true, deliverAs: "followUp" });
+        },
         jobsChanged: () => panel.refresh(),
         thinkingLevel: () => pi.getThinkingLevel(),
         context: contextNow,
@@ -473,8 +521,12 @@ function turriExtension(api, session, link) {
                     "the ***plain reference is in its prompt, and it runs its own skills with cultivate.", "info");
             }
         }
+        if (isSentinel) {
+            const prompt = [event.systemPrompt, sentinelPrompt(cwd, { extraTools: hostSentinelTools.map((tool) => tool.name) }), projectConfigBlock(cwd), rulesBlock()].join("\n\n");
+            return { systemPrompt: host.systemPrompt !== undefined ? host.systemPrompt(prompt) : prompt };
+        }
         return {
-            systemPrompt: conversationSystemPrompt(event.systemPrompt, host, [TOOLS_NOT_CLI, NEW_PROJECT, projectConfigBlock(cwd), machineBlock(cwd, machine.now()), rulesBlock()]),
+            systemPrompt: conversationSystemPrompt(event.systemPrompt, host, [TOOLS_NOT_CLI, NEW_PROJECT, pulseEndsBlock(session.sentinelOn()), projectConfigBlock(cwd), machineBlock(cwd, machine.now()), rulesBlock()]),
         };
     });
     // The conversation's agent does not run turri again through its shell, unless the person
@@ -492,6 +544,10 @@ function turriExtension(api, session, link) {
         return { action: "continue" };
     });
     pi.on("tool_call", (event) => {
+        // The sentinel reads, and puts what it finds to the person: whatever else it calls is refused.
+        if (isSentinel && !sentinelAllowed.has(event.toolName)) {
+            return { block: true, reason: `The sentinel changes nothing: ${event.toolName} is not one of its tools. Put what needs doing to the person with notify_person.` };
+        }
         const command = event.input.command;
         if (event.toolName === "bash" && typeof command === "string") {
             const what = selfInvocation(command);

package/dist/host-session.d.ts

@@ -3,6 +3,7 @@ import type { AskUserIO } from "./ask.ts";
 import { type ChatInfo, type TurriHost } from "./chats.ts";
 import type { JobRegistry } from "./regenerate/jobs.ts";
 import type { WorkLoop } from "./regenerate/loop.ts";
+import type { Notice, NoticeAnswer } from "./notice.ts";
 /**
  * turri's session for a host that runs its chats itself - a desktop app, an editor: the chats, each a pi session with
  * turri in it, on one job registry and work loop. The host shows each chat in its own way - subscribes to its session,
@@ -60,6 +61,16 @@ export interface Turri {
      * stops the turn. `none` when the chat asks nothing now, `missing` for a chat not open.
      */
     decline(id: string): Promise<"declined" | "none" | "missing">;
+    /**
+     * The notices put to the person and not yet over - the sentinel's, and turri's own: each in the chat it names. A host
+     * hears each as it is put (`onNotice`) and as it ends (`onNoticeOver`).
+     */
+    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.
+     */
+    answer(id: string, answer: NoticeAnswer): Promise<"done" | "dismissed" | "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-session.js

@@ -67,6 +67,8 @@ export async function createTurri(options = {}) {
             return did;
         },
         decline: async (id) => core.decline(id),
+        notices: () => core.notices(),
+        answer: async (id, answer) => core.answer(id, answer),
         onChats: (listener) => core.onChats(() => listener(core.chats())),
         dispose,
     };

package/dist/host.d.ts

@@ -6,6 +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 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

@@ -7,6 +7,8 @@
 // The session and its chats.
 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";
 /** 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/identity.js

@@ -50,8 +50,8 @@ const IDENTITY_BEFORE = [
     "",
     "The person may have several chats with you open on this project at once, this one among them. What regenerates is",
     "the same in every chat: the pulses and their plan, steering, the engine's coding model and what activate started -",
-    "pulses lists every pulse, whichever chat asked for it, and you are told when one asked for here ends. What was said",
-    "in another chat is not in this one: when the person speaks of it, ask.",
+    "pulses lists every pulse, whichever chat asked for it. What was said in another chat is not in this one: when the",
+    "person speaks of it, ask.",
     "",
     "Your words, and the older ones for the same things - a project's AGENTS.md, a skill, notes or the person may use",
     "either, and they mean the same:",

package/dist/init-config.d.ts

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

package/dist/init-config.js

@@ -220,6 +220,7 @@ export const DEFAULTS = {
     mutationTesting: true,
     allowToStopJobs: true,
     releaseAfterPulse: true,
+    sentinel: true,
     testingScriptsRunOn: "in-place",
     turnLimit: 120,
     compactAt: 100000,
@@ -264,6 +265,10 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         "# Whether every pulse that lands code releases it, as the project's release guidance says.",
         `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.",
+        `sentinel: ${DEFAULTS.sentinel}`,
+        "",
         "# What the testing scripts run on: in-place - the code itself; copy - a fresh copy of it.",
         `testing-scripts-run-on: ${DEFAULTS.testingScriptsRunOn}`,
         "",
@@ -330,6 +335,7 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         "# models:",
         `#   default: ${coding}`,
         `${column(`#   chat: ${harness}`, 72)}# the conversation - as harness-model, which it wins over`,
+        `${column(`#   sentinel: ${harness}`, 72)}# the sentinel: checks every finished pulse and tests the release`,
         role("chooser", harness, "chooses what gets conformance tests under turri regenerate"),
         role("planner", harness, "cuts the work into pulses"),
         role("diagnosis", harness, "looks into a pulse that failed for good"),

package/dist/notice.d.ts

@@ -0,0 +1,59 @@
+import type { Job } from "./regenerate/jobs.ts";
+/**
+ * The sentinel's name and its notices - what it puts to the person - with nothing else: the session's chats (chats.ts)
+ * hold them, and load early, before the sentinel's tools and what they need (sentinel.ts) can be.
+ */
+/** Its name in the strip, the host's chat list, and the ledger. */
+export declare const SENTINEL = "sentinel";
+export type ChatRole = typeof SENTINEL;
+export type NoticeSeverity = "error" | "warning" | "info";
+/** One thing the person can do about a notice: accepted, the focused chat's agent is started on `task`. */
+export interface NoticeAction {
+    label: string;
+    task: string;
+}
+export interface NoticeInput {
+    severity: NoticeSeverity;
+    /** What is wrong, in a line. */
+    summary: string;
+    /** What shows it: a step that failed, a log's lines, a test's output. */
+    evidence: string[];
+    actions: NoticeAction[];
+    module?: string;
+    /** The pulse it is about: its job id. */
+    job?: string;
+    /** Its number among its module's pulses. */
+    pulse?: number;
+}
+export type NoticeState = "open" | "accepted" | "steered" | "dismissed" | "superseded";
+export interface Notice extends NoticeInput {
+    id: string;
+    /** The chat it is put in: the one the person looks at, never the sentinel's. */
+    chat: string;
+    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. */
+export type NoticeAnswer = {
+    action: number | string;
+} | {
+    steer: string;
+} | {
+    dismiss: true;
+};
+export declare function newNotice(input: NoticeInput, chat: string): Notice;
+/** 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;
+/** 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. */
+export declare function wentWrong(job: Job): boolean;
+/** The sentinel done with a pulse: whether what it checked holds, and what it checked and found, in a line or two. */
+export interface Conclusion {
+    /** The pulse: its job id. */
+    job: string;
+    verdict: "holds" | "wrong";
+    summary: string;
+    module?: string;
+    pulse?: number;
+}

package/dist/notice.js

@@ -0,0 +1,38 @@
+import { randomUUID } from "node:crypto";
+/**
+ * The sentinel's name and its notices - what it puts to the person - with nothing else: the session's chats (chats.ts)
+ * hold them, and load early, before the sentinel's tools and what they need (sentinel.ts) can be.
+ */
+/** Its name in the strip, the host's chat list, and the ledger. */
+export const SENTINEL = "sentinel";
+export function newNotice(input, chat) {
+    return { ...input, id: randomUUID().slice(0, 8), chat, state: "open", at: new Date().toISOString() };
+}
+/** 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)
+        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"}:`,
+        describeNotice(notice),
+        "",
+    ];
+    if ("steer" in answer)
+        return [...head, `The person answered it in their own words - do what they say:`, answer.steer.trim()].join("\n");
+    const action = typeof answer.action === "number" ? notice.actions[answer.action] : notice.actions.find((candidate) => candidate.label === answer.action);
+    if (action === undefined)
+        return undefined;
+    return [...head, `The person chose: ${action.label}. Do it now:`, action.task.trim()].join("\n");
+}
+/** 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 [
+        `${notice.severity === "error" ? "✗" : notice.severity === "warning" ? "!" : "·"} ${notice.summary}`,
+        ...notice.evidence.map((line) => `  ${line}`),
+        ...(notice.actions.length > 0 ? ["What can be done:", ...notice.actions.map((action, index) => `  ${index + 1}. ${action.label}`)] : []),
+    ].join("\n");
+}
+/** Whether a pulse went wrong: failed, stopped, or ran to its end with what it built not passing. */
+export function wentWrong(job) {
+    return job.status !== "succeeded" || job.details?.passed === false;
+}

package/dist/pi-launch.js

@@ -61,10 +61,17 @@ if (interactive) {
     let restore;
     const asked = args.findIndex((arg) => arg === "--continue" || arg === "-c");
     const saved = asked !== -1 ? lastRun(process.cwd()) : undefined;
+    // pi reopens the first of the person's chats as its own; the rest - the sentinel among them - are opened beside it.
+    const first = saved?.chats.find((chat) => chat.role === undefined);
     if (saved !== undefined) {
-        args.splice(asked, 1, "--session", saved.chats[0].sessionFile);
+        if (first !== undefined)
+            args.splice(asked, 1, "--session", first.sessionFile);
+        else
+            args.splice(asked, 1);
         restore = saved;
     }
-    driveTerminal(processSession(() => createTurriCore({}, { persist: true })), restore !== undefined ? { restore } : {});
+    driveTerminal(processSession(() => createTurriCore({}, { persist: true })), 
+    // With none of the person's chats saved - only the sentinel's - pi starts a fresh one, and every saved chat is opened beside it.
+    restore !== undefined ? { restore, skipFirst: restore.chats.some((chat) => chat.role === undefined) } : {});
 }
 await main(args, { extensionFactories });

package/dist/regenerate/agent-shell.d.ts

@@ -13,6 +13,11 @@ export interface ShellRole {
     read?: string[];
     /** The folders it may write; its workdir when not given, none for a role that only reads. */
     write?: string[];
+    /**
+     * The module folder its home, TMPDIR and caches are kept for - its workdir's module when not given: for a role whose
+     * folder is no module's, the sentinel's the project itself.
+     */
+    home?: string;
 }
 export interface AgentShell {
     /** The wall under the check and the audit. */

package/dist/regenerate/agent-shell.js

@@ -7,7 +7,7 @@ import { afterCommand, auditMessage, beforeCommand } from "./audit.js";
 import { checkCommand, machineReadable } from "./command-check.js";
 import { darwinUserDirs, machineFor, sandboxAvailable, sandboxWrap } from "./os-sandbox.js";
 import { MODULES_DIR, projectRootOf } from "./paths.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 import { runCommand } from "./shell.js";
 /**
  * What a module's shell writes beside its roots: its home, its TMPDIR, the package caches - and on macOS its own folder
@@ -28,7 +28,7 @@ export function agentShell(role, options = {}) {
     const workdir = resolve(role.workdir);
     const read = (role.read ?? [workdir]).map((dir) => resolve(dir));
     const write = (role.write ?? [workdir]).map((dir) => resolve(dir));
-    const moduleDir = moduleOf(workdir);
+    const moduleDir = role.home !== undefined ? resolve(role.home) : moduleOf(workdir);
     const project = projectRootOf(workdir);
     const { env } = agentEnvironment(moduleDir);
     const root = projectRootOf(moduleDir);

package/dist/regenerate/audit.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, wri
 import { basename, dirname, join, relative, sep } from "node:path";
 import { writtenByConversation } from "./conversation-writes.js";
 import { isCredentialFile } from "./credentials.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 /** Folders never looked in: dependencies, build output, caches, histories, turri's scratch. */
 const SKIPPED = new Set([
     "node_modules", ".venv", "venv", "__pycache__", ".pytest_cache", ".mypy_cache", ".ruff_cache", ".tox", "target", "build",

package/dist/regenerate/codebase.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { NOTES_FILE } from "./notes.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 import { listFiles } from "./testing.js";
 /**
  * What a render agent is told about the code before it starts.

package/dist/regenerate/command-check.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { posix, win32 } from "node:path";
 import { isCredentialFile } from "./credentials.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 /** What of the machine an agent's command may read, beside its roots and its toolchains: the system's own folders. */
 export function machineReadable(platform = process.platform) {
     if (platform === "win32") {

package/dist/regenerate/confine.d.ts

@@ -29,6 +29,8 @@ export interface Confinement {
      * and run code: the coding agents and the conformance agent. Observers, explorers and judges never do.
      */
     reportsEnvironment?: boolean;
+    /** Whose home and temporary folder its shell has, by the module folder they are kept for - its workdir's module when not given. */
+    shellHome?: string;
 }
 export declare class ConfinementError extends Error {
     constructor(message: string);

package/dist/regenerate/confine.js

@@ -4,7 +4,7 @@ import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { credentialRefusal, isCredentialFile } from "./credentials.js";
 import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "@earendil-works/pi-coding-agent";
 import { NOTES_FILE } from "./notes.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 import { keptShellOutput, outputsDir, readOutputTool } from "./testing.js";
 import { reportLogNote } from "./activity.js";
 import { agentShell } from "./agent-shell.js";
@@ -266,7 +266,7 @@ export function confinedTools(c) {
         description += ", no bash";
     }
     else {
-        const shell = agentShell({ workdir, read, write }, { busy: anotherPulseIn });
+        const shell = agentShell({ workdir, read, write, ...(c.shellHome !== undefined ? { home: c.shellHome } : {}) }, { busy: anotherPulseIn });
         const bash = createBashToolDefinition(workdir, { operations: hostBashOperations(shell), exposeSessionEnvironment: false });
         bash.description = `${bash.description}\n\n${hostEnvironmentNote()}\n\n${timeLimitNote()}`;
         tools.push(withKeptOutput(bash, workdir));

package/dist/regenerate/ledger.d.ts

@@ -50,6 +50,20 @@ export type LedgerEvent = {
 } | {
     kind: "chat.opened";
     reopened: boolean;
+    role?: string;
+} | {
+    kind: "notice.put";
+    notice: string;
+    severity: string;
+    module?: string;
+} | {
+    kind: "notice.over";
+    notice: string;
+    state: string;
+} | {
+    kind: "sentinel.concluded";
+    verdict: string;
+    module?: string;
 } | {
     kind: "chat.closed";
 } | {

package/dist/regenerate/paths.d.ts

@@ -1,3 +1,5 @@
+/** A module's code record and its tests' - `code/.turri.json`, `tests/.turri.json` (records.ts). */
+export declare const RECORD_FILE = ".turri.json";
 /**
  * The ***plain standard library: import modules for generic pieces of software that ship with turri,
  * imported as `stdlib/backend/python-fastapi` - a reserved name (see plain/stdlib.ts).

package/dist/regenerate/paths.js

@@ -1,6 +1,8 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+/** A module's code record and its tests' - `code/.turri.json`, `tests/.turri.json` (records.ts). */
+export const RECORD_FILE = ".turri.json";
 /**
  * The ***plain standard library: import modules for generic pieces of software that ship with turri,
  * imported as `stdlib/backend/python-fastapi` - a reserved name (see plain/stdlib.ts).

package/dist/regenerate/records.d.ts

@@ -12,7 +12,7 @@ import { type MarshalledPlainSource } from "../plain/spec.ts";
  * functionality, and only functionality in the code can be tested. Each record is committed with
  * what it describes, in the module's `.plaingit`, so rolling a unit of work back puts it back too.
  */
-export declare const RECORD_FILE = ".turri.json";
+export { RECORD_FILE } from "./paths.ts";
 /**
  * A functional spec in the code record marked to regenerate again: its code is built, and is to be regenerated again
  * all the same - `regenerate` with functionalities named. The mark makes the record differ from the spec at that item,

package/dist/regenerate/records.js

@@ -16,7 +16,9 @@ import { committedText } from "./lineage.js";
  * functionality, and only functionality in the code can be tested. Each record is committed with
  * what it describes, in the module's `.plaingit`, so rolling a unit of work back puts it back too.
  */
-export const RECORD_FILE = ".turri.json";
+// Defined beside the paths, which import nothing of turri's: what reads it as it loads - testing.ts - never waits on this module.
+export { RECORD_FILE } from "./paths.js";
+import { RECORD_FILE } from "./paths.js";
 /**
  * A functional spec in the code record marked to regenerate again: its code is built, and is to be regenerated again
  * all the same - `regenerate` with functionalities named. The mark makes the record differ from the spec at that item,

package/dist/regenerate/release.js

@@ -6,7 +6,7 @@ import { HISTORY_DIR } from "./lineage.js";
 import { NOTES_FILE } from "./notes.js";
 import { distDirFor, ensureInScratch, projectDirOf } from "./paths.js";
 import { findCodebaseTip } from "./requires.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 function git(moduleDir, args) {
     return spawnSync("git", ["--git-dir", join(moduleDir, HISTORY_DIR), "--work-tree", moduleDir, ...args], { cwd: moduleDir, encoding: "utf8" });
 }

package/dist/regenerate/testing.js

@@ -6,7 +6,7 @@ import { reportActivity } from "./activity.js";
 import { maskSecrets } from "./masking.js";
 import { NOTES_FILE } from "./notes.js";
 import { modulesScratchDir } from "./paths.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 import { missingToolchain, runUnitScript, scriptFailure } from "./test-scripts.js";
 import { COMMAND_TIMEOUT_MS } from "./shell.js";
 import { pulseWrote } from "./pulse-files.js";

package/dist/regenerate/workspace.js

@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import { projectImplementationReqs, stackOf } from "../stack.js";
 import { MODULES_DIR, projectRootOf } from "./paths.js";
-import { RECORD_FILE } from "./records.js";
+import { RECORD_FILE } from "./paths.js";
 import { listFiles } from "./testing.js";
 /**
  * What an agent is told up front about its folder and this machine, beside its walls - what agents otherwise go looking

package/dist/sentinel-chat.d.ts

@@ -0,0 +1,14 @@
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+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;
+/**
+ * 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.
+ */
+export declare function noticeDialogs(pi: ExtensionAPI, session: TurriCore, link: ChatLink, context: () => ExtensionContext | undefined): {
+    put(notice: Notice): void;
+    over(notice: Notice): void;
+    concluded(conclusion: Conclusion): void;
+};