@turri-dev/cli 0.1.16 → 0.1.17-next.63f454c

package/dist/genome.d.ts

@@ -17,12 +17,7 @@ export interface RunSkillResult {
     /** The last step's artifact - what the caller usually wants. */
     output: string;
 }
-/**
- * Run one skill to completion. The only entry point: the CLI and the Pi extension
- * both go through here, so a skill behaves identically whether a human launched it
- * or a conversational agent decided to.
- */
-export declare function runSkill(opts: {
+export interface RunSkillOptions {
     skillDir: string;
     cwd: string;
     runDir: string;
@@ -51,7 +46,18 @@ export declare function runSkill(opts: {
     loopTools?: ToolDefinition[];
     /** The jobs the render queue runs, for a skill that waits for its builds and reads what they recorded. */
     jobs?: JobRegistry;
-}): Promise<RunSkillResult>;
+    /**
+     * Stops the run: its agents end their turns and it throws JobStoppedError, its manifest left as it was - an
+     * interrupted run, for `resume` to pick up. What it started on the work loop goes on.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Run one skill to completion. The only entry point: the CLI and the Pi extension
+ * both go through here, so a skill behaves identically whether a human launched it
+ * or a conversational agent decided to.
+ */
+export declare function runSkill(opts: RunSkillOptions): Promise<RunSkillResult>;
 /** Whether there is a run of this skill here that was interrupted, and could be resumed. */
 export declare function interruptedRun(runDir: string, skillName: string): {
     step?: string;

package/dist/genome.js

@@ -4,11 +4,11 @@ import { Command, MemorySaver } from "@langchain/langgraph";
 import { compileSkill } from "./graph.js";
 import { createExecutor } from "./pi.js";
 import { toolchainsBlock } from "./stack.js";
-import { describeToolCall, describeToolResult } from "./regenerate/activity.js";
+import { clearOfStop, describeToolCall, describeToolResult, withStopSignal } from "./regenerate/activity.js";
 import { createLiveReviewer } from "./review/live.js";
 import { loadSkill, readRubric } from "./skill.js";
 import { createAskUserTool, createEndQuestionsTool, createReviewTools, createWriteArtifactTool, withReviewNote } from "./tools.js";
-import { DISMISSED } from "./ask.js";
+import { DECLINED, DISMISSED } from "./ask.js";
 import { createQuestioning, levelOf, questioningQuestion } from "./questioning.js";
 import { createSpecDiffTools } from "./spec-tools.js";
 import { createMatureTools, MATURE_TOOLS } from "./mature-tools.js";
@@ -23,6 +23,16 @@ const SAID_MAX = 6000;
  * or a conversational agent decided to.
  */
 export async function runSkill(opts) {
+    if (opts.signal === undefined)
+        return runStoppable(opts);
+    return withStopSignal(opts.signal, () => runStoppable({
+        ...opts,
+        ...(opts.renderQueue !== undefined ? { renderQueue: clearOfStop(opts.renderQueue) } : {}),
+        ...(opts.jobs !== undefined ? { jobs: clearOfStop(opts.jobs) } : {}),
+        ...(opts.loopTools !== undefined ? { loopTools: opts.loopTools.map(clearOfStop) } : {}),
+    }));
+}
+async function runStoppable(opts) {
     const skill = loadSkill(opts.skillDir);
     const runDir = resolve(opts.runDir);
     // A resumed run keeps its folder - the artifacts are in it - and starts where it stopped.
@@ -102,7 +112,7 @@ export async function runSkill(opts) {
         customTools.push(createAskUserTool(opts.askUser, (answer, confirmsPhase) => {
             said = "";
             // A phase's confirmation, or a question dismissed, owes the spec nothing.
-            diffs?.pace.answered(!confirmsPhase && answer !== DISMISSED);
+            diffs?.pace.answered(!confirmsPhase && answer !== DISMISSED && answer !== DECLINED);
         }, () => said, holdsQuestions ? questions : undefined));
         if (capsQuestions)
             customTools.push(createEndQuestionsTool(questions));

package/dist/host-session.d.ts

@@ -0,0 +1,58 @@
+import { type AgentSession, type ExtensionFactory, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+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";
+/**
+ * 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,
+ * prompts it - and tells turri which one its person looks at (`focus`): a pulse a closed chat asked for is reported
+ * there.
+ */
+export interface TurriOptions extends Omit<TurriHost, "dialogs"> {
+    /** pi's folder - its settings, models and credentials. Default: pi's own (`~/.pi/agent`). */
+    agentDir?: string;
+    /** Where the chats' conversations are saved. Default: pi's own folder for this project. */
+    sessionDir?: string;
+    /** The host's own extensions, built into every chat after turri's. */
+    extensions?: ExtensionFactory[];
+    /** The dialogs a chat's questions are put in - ask_user's, a skill's interview, a review gate's - by the chat's id. */
+    dialogs?: (chat: string) => AskUserIO | undefined;
+    /** What a chat's other UI calls - its notices, its working line - come to, by the chat's id. */
+    uiContext?: (chat: string) => ExtensionUIContext | undefined;
+    /** Reopen the chats of the last session here that has ended, in their order - as `turri --continue` does. */
+    restore?: boolean;
+}
+export interface Turri {
+    /** The session's job registry: every pulse any chat starts. */
+    readonly jobs: JobRegistry;
+    /** The session's work loop - once a chat is open: what each codebase has planned, and why. */
+    readonly loop: WorkLoop;
+    /** The chats, in their order. */
+    chats(): ChatInfo[];
+    /** A chat's pi session: to subscribe to, prompt and abort. */
+    session(id: string): AgentSession | undefined;
+    /** A fresh chat - or the saved one `sessionFile` is. At most nine are open. */
+    openChat(options?: {
+        sessionFile?: string;
+    }): Promise<ChatInfo & {
+        session: AgentSession;
+    }>;
+    /** A chat closed: its turn stopped, its conversation deleted - its pulses run on. */
+    closeChat(id: string): Promise<void>;
+    /** The chat the person looks at now. */
+    focus(id: string): void;
+    /**
+     * ctrl+c in a chat, as the terminal has it: what the chat is doing stopped - its turn, a skill or a tool in it, a `!`
+     * command, a compaction - and nothing in the others (`stopped`). In a chat doing nothing the session ends - every
+     * chat let go and what activate started stopped, as `dispose` does - for the host to close what showed it (`ended`).
+     * A second interrupt straight after one that stopped something does nothing (`ignored`); `missing` for a chat not open.
+     */
+    interrupt(id: string): Promise<"stopped" | "ignored" | "ended" | "missing">;
+    /** 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. */
+    dispose(): Promise<void>;
+}
+/** turri's session in a host, in the process's working folder - the project's. */
+export declare function createTurri(options?: TurriOptions): Promise<Turri>;

package/dist/host-session.js

@@ -0,0 +1,72 @@
+import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from "@earendil-works/pi-coding-agent";
+import { lastRun } from "./chat-records.js";
+import { interruptChat } from "./chats.js";
+import { createTurriCore, sessionLoop } from "./extension.js";
+import { stopDeployed } from "./regenerate/release.js";
+/** turri's session in a host, in the process's working folder - the project's. */
+export async function createTurri(options = {}) {
+    const { dialogs, uiContext, extensions = [], agentDir = getAgentDir(), sessionDir, restore, ...host } = options;
+    const core = createTurriCore(host, { persist: true, ...(dialogs !== undefined ? { dialogs } : {}) });
+    const cwd = core.cwd;
+    core.setDriver({
+        async create(chat, sessionFile) {
+            const resourceLoader = new DefaultResourceLoader({ cwd, agentDir, extensionFactories: [core.extension, ...extensions] });
+            await resourceLoader.reload();
+            const sessionManager = sessionFile !== undefined ? SessionManager.open(sessionFile, sessionDir) : SessionManager.create(cwd, sessionDir);
+            const { session } = await createAgentSession({ cwd, agentDir, resourceLoader, sessionManager });
+            chat.session = session;
+            await session.bindExtensions({ uiContext: uiContext?.(chat.id), mode: "tui" });
+        },
+        async dispose(chat) {
+            const session = chat.session;
+            if (session === undefined)
+                return;
+            try {
+                await session.abort();
+            }
+            finally {
+                session.dispose();
+            }
+        },
+    });
+    if (restore === true) {
+        const saved = lastRun(cwd);
+        if (saved !== undefined)
+            await core.restore(saved);
+        const first = core.chats()[0];
+        if (first !== undefined)
+            await core.show(first.id);
+    }
+    let lastStop = 0;
+    const dispose = async () => {
+        await core.dispose();
+        await stopDeployed();
+    };
+    return {
+        jobs: core.jobs,
+        get loop() {
+            return sessionLoop(core);
+        },
+        chats: () => core.chats(),
+        session: (id) => core.session(id),
+        async openChat(asked = {}) {
+            const chat = await core.open(asked);
+            return { ...chat, session: core.session(chat.id) };
+        },
+        closeChat: (id) => core.close(id),
+        focus: (id) => void core.show(id),
+        async interrupt(id) {
+            const session = core.session(id);
+            if (session === undefined)
+                return "missing";
+            const did = interruptChat(session, { lastStop, idle: () => "ended" });
+            if (did === "stopped")
+                lastStop = Date.now();
+            if (did === "ended")
+                await dispose();
+            return did;
+        },
+        onChats: (listener) => core.onChats(() => listener(core.chats())),
+        dispose,
+    };
+}

package/dist/host.d.ts

@@ -1,12 +1,13 @@
 /**
- * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the
- * conversation as pi's extension, with the host told of its jobs and asking its questions (createTurriExtension), and
+ * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the session and
+ * its chats, with the host told of its jobs and asking its questions (createTurri), and
  * what a host shows beside it - a spec parsed, checked and coloured, its concepts and links, the standard library, how
  * far each functional spec is built, the work a spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
  */
-export { createTurriExtension, type TurriHost } from "./extension.ts";
+export { createTurri, type Turri, type TurriOptions } from "./host-session.ts";
+export { MAX_CHATS, type ChatInfo, type ChatStatus, type TurriHost } from "./chats.ts";
 export type { AskUserIO } from "./ask.ts";
-/** pi itself, as turri's extension is built against it: a host makes its session with this one, not another copy. */
+/** 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";
 export { configForSpec, debugMode, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf, type ProjectConfig } from "./config.ts";
 export { MODULES_DIR, projectDirOf, resolveTemplateDirs } from "./regenerate/paths.ts";

package/dist/host.js

@@ -1,12 +1,13 @@
 /**
- * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the
- * conversation as pi's extension, with the host told of its jobs and asking its questions (createTurriExtension), and
+ * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the session and
+ * its chats, with the host told of its jobs and asking its questions (createTurri), and
  * what a host shows beside it - a spec parsed, checked and coloured, its concepts and links, the standard library, how
  * far each functional spec is built, the work a spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
  */
-// The conversation.
-export { createTurriExtension } from "./extension.js";
-/** pi itself, as turri's extension is built against it: a host makes its session with this one, not another copy. */
+// The session and its chats.
+export { createTurri } from "./host-session.js";
+export { MAX_CHATS } from "./chats.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.
 export { configForSpec, debugMode, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf } from "./config.js";

package/dist/identity.js

@@ -48,6 +48,11 @@ const IDENTITY_BEFORE = [
     "turri in the third person, as if it were someone else, and never tell the person to tell or ask turri something:",
     "they are talking to turri. What they should ask for, they ask you for, here.",
     "",
+    "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.",
+    "",
     "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:",
     "- A pulse is one unit of work regenerating the code - a spec diff regenerated in a codebase, or its conformance",

package/dist/pi-launch.js

@@ -12,6 +12,9 @@ import { main, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { ProcessTerminal } from "@earendil-works/pi-tui";
 import "./terminal-images.js";
 import { resumeLine } from "./resume-line.js";
+import { lastRun } from "./chat-records.js";
+import { driveTerminal } from "./chat-terminal.js";
+import turri, { createTurriCore, processSession } from "./extension.js";
 /**
  * pi, started the way its own CLI starts it, for `turri`.
  *
@@ -21,6 +24,8 @@ import { resumeLine } from "./resume-line.js";
  * quiet every `pi` on the machine, so it is answered for this run instead. `--verbose` still shows it.
  */
 const args = process.argv.slice(2);
+/** Set by cli.ts when pi loads turri's extension itself - an older turri installed it into every pi. */
+const GLOBAL_EXTENSION = "TURRI_EXTENSION_IN_PI";
 if (!args.includes("--verbose")) {
     SettingsManager.prototype.getQuietStartup = () => true;
 }
@@ -42,4 +47,21 @@ process.stdout.write = ((chunk, ...rest) => write(typeof chunk === "string" ? re
 const setup = pathToFileURL(join(dirname(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), "cli", "setup.js")).href;
 const { setupCli } = (await import(__rewriteRelativeImportExtension(setup)));
 setupCli();
-await main(args);
+// turri's session, with its chats: built into pi here, in this process, rather than loaded from a file - one session
+// the terminal's chats share (chats.ts). An older turri installed into every pi loads it itself: cli.ts says so, and
+// it is not built in twice.
+const extensionFactories = process.env[GLOBAL_EXTENSION] === "1" ? [] : [turri];
+// pi's terminal - not its print, json or rpc modes, nor a run given its input on stdin - holds several chats, and
+// records them for `turri --continue`, which opens them all again: the first as pi's own session, the rest beside it.
+const interactive = process.stdin.isTTY === true && !args.some((arg) => ["-p", "--print", "--mode", "--help", "-h", "--version", "-v", "--list-models"].includes(arg) || arg.startsWith("--mode="));
+if (interactive) {
+    let restore;
+    const asked = args.findIndex((arg) => arg === "--continue" || arg === "-c");
+    const saved = asked !== -1 ? lastRun(process.cwd()) : undefined;
+    if (saved !== undefined) {
+        args.splice(asked, 1, "--session", saved.chats[0].sessionFile);
+        restore = saved;
+    }
+    driveTerminal(processSession(() => createTurriCore({}, { persist: true })), restore !== undefined ? { restore } : {});
+}
+await main(args, { extensionFactories });

package/dist/question-dialog.d.ts

@@ -25,6 +25,8 @@ export interface QuestionDialogOptions {
     style: DialogStyle;
     /** The answer - an option, or what was typed - or undefined, dismissed. */
     done: (answer: string | undefined) => void;
+    /** ctrl+c: the question declined, the asker deciding what that stops (askUserVia). Without it, dismissed as esc is. */
+    interrupt?: () => void;
     /** Draw again: a key changed what shows. */
     requestRender: () => void;
 }
@@ -42,6 +44,8 @@ export declare class QuestionDialog implements Component, Focusable {
     constructor(options: QuestionDialogOptions);
     get focused(): boolean;
     set focused(value: boolean);
+    /** Closed, no answer given: the question declined from outside - its turn stopped. */
+    dismiss(): void;
     private finish;
     private scrollBy;
     render(width: number): string[];

package/dist/question-dialog.js

@@ -36,6 +36,10 @@ export class QuestionDialog {
         if (this.input !== undefined)
             this.input.focused = value;
     }
+    /** Closed, no answer given: the question declined from outside - its turn stopped. */
+    dismiss() {
+        this.finish(undefined);
+    }
     finish(answer) {
         if (this.answered)
             return;
@@ -65,8 +69,8 @@ export class QuestionDialog {
                     return index === this.selected ? style.accent(shown) : shown;
                 }));
         const hint = this.input !== undefined
-            ? "enter answers · esc dismisses"
-            : "↑↓ choose · enter picks · esc dismisses";
+            ? "enter answers · esc dismisses · ctrl+c declines"
+            : "↑↓ choose · enter picks · esc dismisses · ctrl+c declines";
         // The brief gets what the question, the options and the hints leave of the screen.
         const fixed = question.length + body.length + 5;
         const room = Math.max(3, this.options.rows() - KEPT_ABOVE - fixed);
@@ -89,6 +93,13 @@ export class QuestionDialog {
         return lines;
     }
     handleInput(data) {
+        if (matchesKey(data, "ctrl+c")) {
+            if (this.options.interrupt !== undefined)
+                this.options.interrupt();
+            else
+                this.finish(undefined);
+            return;
+        }
         // The brief scrolls whatever has the keys.
         if (matchesKey(data, "pageDown"))
             return this.scrollBy(Math.max(1, this.window - 1));

package/dist/regenerate/activity.d.ts

@@ -84,8 +84,15 @@ export declare function reportSpecConflict(conflict: SpecConflict): void;
 export declare class JobStoppedError extends Error {
     constructor();
 }
-/** The stop signal of the job this code is running for, if it is running for one. */
+/** The stop signal of the job this code is running for - else of the work outside a job it runs for - if there is one. */
 export declare function currentStopSignal(): AbortSignal | undefined;
+/** Run work for no job that `signal` stops: every agent under it ends its turn, and the work unwinds with JobStoppedError. */
+export declare function withStopSignal<T>(signal: AbortSignal | undefined, run: () => Promise<T>): Promise<T>;
+/**
+ * What work under withStopSignal hands on to the session - the work loop, the job registry - with each of its methods
+ * run clear of that signal: a pulse or a plan started from a skill outlives the skill being stopped.
+ */
+export declare function clearOfStop<T extends object>(given: T): T;
 /** The job this code is running for, if it is running for one. */
 export declare function currentJob(): {
     id: string;

package/dist/regenerate/activity.js

@@ -14,9 +14,30 @@ export class JobStoppedError extends Error {
         this.name = "JobStoppedError";
     }
 }
-/** The stop signal of the job this code is running for, if it is running for one. */
+/** What stops work that runs for no job - a skill run, stopped with the chat's turn that runs it (withStopSignal). */
+const stops = new AsyncLocalStorage();
+/** The stop signal of the job this code is running for - else of the work outside a job it runs for - if there is one. */
 export function currentStopSignal() {
-    return store.getStore()?.signal;
+    const sink = store.getStore();
+    return sink !== undefined ? sink.signal : stops.getStore();
+}
+/** Run work for no job that `signal` stops: every agent under it ends its turn, and the work unwinds with JobStoppedError. */
+export function withStopSignal(signal, run) {
+    return stops.run(signal, run);
+}
+/**
+ * What work under withStopSignal hands on to the session - the work loop, the job registry - with each of its methods
+ * run clear of that signal: a pulse or a plan started from a skill outlives the skill being stopped.
+ */
+export function clearOfStop(given) {
+    return new Proxy(given, {
+        get(target, key, receiver) {
+            const value = Reflect.get(target, key, receiver);
+            if (typeof value !== "function")
+                return value;
+            return (...args) => stops.run(undefined, () => value.apply(target, args));
+        },
+    });
 }
 /** The job this code is running for, if it is running for one. */
 export function currentJob() {

package/dist/regenerate/jobs.d.ts

@@ -31,6 +31,8 @@ export interface Job {
     model?: string;
     /** The stack it is built with - its config.turri.<stack>.yaml over config.turri.yaml - as chosen when it was queued. */
     stack?: string;
+    /** The chat it was asked for in (chat-scope.ts): the one told how it went. */
+    chat?: string;
     status: JobStatus;
     /** Monotonic start order. Two jobs can share a millisecond, so ordering uses this. */
     sequence: number;

package/dist/regenerate/jobs.js

@@ -6,6 +6,7 @@ import { addAgentReport, describeAgents, JobStoppedError, withActivity } from ".
 import { projectOfLanes, startJobLog } from "./job-log.js";
 import { firstLine, healing, record } from "./ledger.js";
 import { chosenStack, debugMode, withStack } from "../config.js";
+import { currentChat } from "../chat-scope.js";
 import { pulseEnded, pulseWrote } from "./pulse-files.js";
 const DEFAULT_TAIL_CHARS = 4000;
 const ACTIVITY_LINES = 10;
@@ -57,6 +58,7 @@ export function createJobRegistry(options) {
             // The stack chosen as it is queued - or pinned for the work that queues it - not as it starts: a job that waits
             // for a slot is built with the stack it was asked for, whatever is chosen meanwhile.
             const stack = chosenStack();
+            const chat = currentChat()?.id;
             const claimed = [...new Set(input.lanes ?? [])];
             const blockers = [
                 ...new Set(claimed
@@ -76,6 +78,7 @@ export function createJobRegistry(options) {
                 diff: input.diff,
                 model: input.model,
                 ...(stack !== undefined ? { stack } : {}),
+                ...(chat !== undefined ? { chat } : {}),
                 ...(input.follows !== undefined ? { follows: input.follows } : {}),
                 status: blockers.length > 0 || (limit !== undefined && active >= limit) ? "queued" : "running",
                 sequence: (sequence += 1),

package/dist/regenerate/ledger.d.ts

@@ -45,6 +45,11 @@ export type LedgerEvent = {
 } | {
     kind: "run.ended";
     ms: number;
+} | {
+    kind: "chat.opened";
+    reopened: boolean;
+} | {
+    kind: "chat.closed";
 } | {
     kind: "job.queued";
     jobKind: string;
@@ -213,6 +218,8 @@ export type LedgerEntry = LedgerEvent & {
     job?: string;
     module?: string;
     agent?: AgentRef;
+    /** The chat the work was asked for in, in a session of several (chat-scope.ts). */
+    chat?: string;
 };
 /** Where an event happened, when not where the code recording it runs: a job's own place is found by itself. */
 export interface LedgerPlace {

package/dist/regenerate/ledger.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, existsSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { gunzipSync, gzipSync } from "node:zlib";
+import { currentChat } from "../chat-scope.js";
 import { readProjectConfig } from "../config.js";
 import { turriIdentity } from "../environment.js";
 import { currentPlace, onModelEvent } from "./activity.js";
@@ -110,7 +111,13 @@ export function record(event, place = {}) {
         return;
     const job = place.job ?? here.job;
     const module = place.module ?? here.module;
-    write(run, resolve(project), event, { ...(job !== undefined ? { job } : {}), ...(module !== undefined ? { module } : {}), ...(place.agent !== undefined ? { agent: place.agent } : {}) });
+    const chat = currentChat()?.id;
+    write(run, resolve(project), event, {
+        ...(job !== undefined ? { job } : {}),
+        ...(module !== undefined ? { module } : {}),
+        ...(place.agent !== undefined ? { agent: place.agent } : {}),
+        ...(chat !== undefined ? { chat } : {}),
+    });
 }
 /**
  * Run a healer - the debugger, the diagnosis of a failed pulse - and record it: started, ended with what it found, or

package/dist/regenerate/test-scripts.d.ts

@@ -167,7 +167,7 @@ export declare function createScriptTool(options: {
     /** Watches the agent's runs for a loop: told once, then its turn is ended. */
     watch?: LoopWatch;
 }): import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{}>, {
-    loop?: "warn" | "stop" | undefined;
+    loop?: "stop" | "warn" | undefined;
     command: string;
     exitCode: number;
 }, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;

package/dist/stacks.d.ts

@@ -1,7 +1,8 @@
 /**
  * Choosing a stack: `config.turri.<stack>.yaml` laid over `config.turri.yaml` for everything built from then on - a
  * backend's testing scripts, then a frontend's. `/stack` and the `stack` tool in the chat, `--stack <name>` on the
- * command line (cli.ts). The choice itself is kept in config.ts (`chooseStack`), for the session only.
+ * command line (cli.ts). The choice itself is kept in config.ts (`chooseStack`): in the chat it is made in, for that chat
+ * alone (chat-scope.ts), each new chat starting from `--stack`.
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 /** The stacks of the projects here: the folder's own, and those of the projects one folder down (specs kept in plain/). */

package/dist/stacks.js

@@ -1,7 +1,8 @@
 /**
  * Choosing a stack: `config.turri.<stack>.yaml` laid over `config.turri.yaml` for everything built from then on - a
  * backend's testing scripts, then a frontend's. `/stack` and the `stack` tool in the chat, `--stack <name>` on the
- * command line (cli.ts). The choice itself is kept in config.ts (`chooseStack`), for the session only.
+ * command line (cli.ts). The choice itself is kept in config.ts (`chooseStack`): in the chat it is made in, for that chat
+ * alone (chat-scope.ts), each new chat starting from `--stack`.
  */
 import { readdirSync } from "node:fs";
 import { join } from "node:path";
@@ -74,10 +75,10 @@ export function registerStacks(pi, cwd) {
         label: "Stack",
         description: "Choose the stack everything is built with from now on - the project's config.turri.yaml with the stack's " +
             "config.turri.<stack>.yaml over it: its testing scripts, toolchains, models - or none, the project's file alone. " +
-            "For the session; a pulse already running keeps the stack it started with. Without a name, says the stacks and the one chosen.",
+            "For this chat alone - each chat chooses its own; a pulse already running keeps the stack it started with. Without a name, says the stacks and the one chosen.",
         promptSnippet: "choose the stack - its testing scripts and settings - that everything is built with",
         promptGuidelines: [
-            "Switch the stack only when the user asks for it, and say which you chose. A module is built with the stack named after it by itself; to build one whose stack has another name, pass that stack as stack to regenerate, conform, glimpse or change_plain instead: it is pinned to that module's pulses, and the session's choice stays as it is.",
+            "Switch the stack only when the user asks for it, and say which you chose. A module is built with the stack named after it by itself; to build one whose stack has another name, pass that stack as stack to regenerate, conform, glimpse or change_plain instead: it is pinned to that module's pulses, and this chat's choice stays as it is.",
         ],
         parameters: Type.Object({
             name: Type.Optional(Type.String({ description: "The stack to choose, or none. Omitted: the stacks there are, and the one chosen" })),

package/docs/README.md

@@ -16,6 +16,7 @@ turri is the first coding agent with the power of regenerative software: [\*\*\*
 | what my machine needs, and why a check failed | [installation](installation.md) |
 | what turri needs of this machine, and what `turri doctor` checks | [installation](installation.md#what-turri-doctor-checks) |
 | how to start a project, or add a feature, in a conversation | [using](using.md#in-a-conversation) |
+| how to have several chats open at once, and reopen them | [chats](chats.md) |
 | which model codes, and how to change it | [using](using.md#choosing-a-model), [the project config](config.md#models) |
 | what `config.turri.yaml` can set, and what happens without it | [the project config](config.md) |
 | how a backend and a frontend on different stacks share one project | [the project config](config.md#stacks) |
@@ -31,7 +32,7 @@ turri is the first coding agent with the power of regenerative software: [\*\*\*
 | what the agents can and cannot reach | [the sandbox](sandbox.md) |
 | how skill review gates and judges work | [skills and gates](skills-and-gates.md) |
 | how the parser matches the reference implementation | [the \*\*\*plain parser](parser.md) |
-| how a desktop app or an editor runs turri's conversation itself | [running turri in a host](hosting.md) |
+| how a desktop app or an editor runs turri's chats itself | [running turri in a host](hosting.md) |
 | where the code for something lives | [development](development.md#layout) |
 
 ## All pages
@@ -40,6 +41,7 @@ turri is the first coding agent with the power of regenerative software: [\*\*\*
 | --- | --- |
 | [Installation](installation.md) | doctor, what turri needs of this machine, turri and `pi`, environment variables |
 | [Using turri](using.md) | the conversation, the tools, background jobs, choosing a model, module history, the command line |
+| [Chats](chats.md) | several chats in one session: what each keeps and what they share, `/chat` and its keys, `turri --continue` and `.turri/chats.json` |
 | [The project config](config.md) | `config.turri.yaml` and each stack's `config.turri.<stack>.yaml`: where they are read from, every key, models and their inheritance, conformance, the testing scripts, stacks and choosing one, the old `config.yaml` |
 | [Deploy](deploy.md) | trying what is built: dist/<module>, the last commit, starting it on your machine, `turri release` |
 | [Running unattended](headless.md) | regenerating overnight or in CI: before you leave it, the command, the results, resuming, rebuilding one functionality |
@@ -49,5 +51,5 @@ turri is the first coding agent with the power of regenerative software: [\*\*\*
 | [Skills and gates](skills-and-gates.md) | the gate syntax, what the harness enforces, what a step can do, the rules, trying the gates |
 | [The \*\*\*plain parser](parser.md) | the TypeScript port, `turri validate`, inheritance, the iterator, fidelity |
 | [Theming](theming.md) | the turri themes, contrast, backgrounds, the font |
-| [Running turri in a host](hosting.md) | `@turri-dev/cli/host`: the conversation in a host's own window - its jobs, its questions - and what a host shows beside it |
+| [Running turri in a host](hosting.md) | `@turri-dev/cli/host`: the session and its chats in a host's own windows - their jobs, their questions - and what a host shows beside them |
 | [Development](development.md) | tests, the source layout, known edges |